001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
003     * agreements. See the NOTICE file distributed with this work for additional information regarding
004     * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the
005     * "License"); you may not use this file except in compliance with the License. You may obtain a
006     * copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable
007     * law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
008     * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
009     * for the specific language governing permissions and limitations under the License.
010     */
011    package javax.portlet.faces;
012    
013    import javax.portlet.ActionRequest;
014    import javax.portlet.ActionResponse;
015    import javax.portlet.EventRequest;
016    import javax.portlet.EventResponse;
017    import javax.portlet.PortletConfig;
018    import javax.portlet.PortletException;
019    import javax.portlet.RenderRequest;
020    import javax.portlet.RenderResponse;
021    import javax.portlet.ResourceRequest;
022    import javax.portlet.ResourceResponse;
023    import javax.portlet.UnavailableException;
024    
025    /**
026     * The <CODE>Bridge</CODE> interface is used by a portlet to execute a JSF artifact. Its lifecycle
027     * follows the pattern used by other web components such as portlets or servlets, namely:
028     * <ul>
029     * <li><code>init</code>: one time (per portlet) initialization. Usually invoked during portlet
030     * <code>init</code> but may also occur lazily. Context is passed to the Bridge at initialization
031     * via <code>PortletContext</code> attributes. See method description for details. </li>
032     * <li><code>doFacesRequest</code>: called for each portlet request that is to be handled by
033     * Faces. Must only be called after the bridge has been initialized. </li>
034     * <li><code>destroy</code>: called to destroy this bridge instance. Usually invoked during
035     * portlet <code>destroy</code> but may also occur earlier if the portlet decides to reclaim
036     * resources. </li>
037     * </ul>
038     * <P>
039     * Portlet developers are encouraged to allow deployers an ability to configure the particular
040     * Bridge implementation it uses within a given deployment. This ensures a best fit solution for a
041     * given application server, portlet container, and/or Faces environment. The specifics for this
042     * configuation are undefined. Each portlet can define a preferred mechanism. Subclasses of
043     * {@link GenericFacesPortlet} automatically inherit this behavior as it recognizes a defined
044     * portlet initialization parameter.
045     * <p>
046     * Implementations of this <code>Bridge</code> interface are required to have a <code>code</code>
047     * constructor.
048     */
049    public interface
050    
051    Bridge
052    {
053    
054      // Base Bridge attribute/context parameter prefix
055      public static final String BRIDGE_PACKAGE_PREFIX = "javax.portlet.faces.";
056    
057      // Following are the names of context init parameters that control
058      // Bridge behavior. These are specified in the web.xml
059    
060      /**
061       * Context initialization parameter that specifies the maximum number of bridge
062       * request scopes to preserved across all uses within this application.
063       */
064      public static final String MAX_MANAGED_REQUEST_SCOPES = 
065        BRIDGE_PACKAGE_PREFIX + "MAX_MANAGED_REQUEST_SCOPES";
066    
067      /**
068       * Context initialization parameter that defines the policy the bridge uses for
069       * rendering.  Parameter value is the string representaiton of one of the 
070       * BridgeRenderPolicy enum values.
071       */
072      public static final String RENDER_POLICY = BRIDGE_PACKAGE_PREFIX + "RENDER_POLICY";
073    
074      /**
075       * Context initialization parameter that defines the lifecycle ID used to 
076       * identify the Faces Lifecycle used for this application.
077       */
078      public static final String LIFECYCLE_ID = "javax.faces.LIFECYCLE_ID";
079    
080      /**
081       * Context initialization parameter that defines the SAVESTATE_FIELD_MARKER
082       * in use in the given deployment.  If not set, consult your bridge implementation
083       * documentation to determine which Faces implementations it automatically
084       * detects and supports.  For example the bridge RI will detect and run
085       * properly in either the Faces RI or MyFaces environments without this being set.
086       */
087      public static final String SAVESTATE_FIELD_MARKER = 
088        BRIDGE_PACKAGE_PREFIX + "SAVESTATE_FIELD_MARKER";
089    
090      // Following are the names of context init attributes set by the portlet to control
091      // Bridge behavior. For the GenericFacesPortlet, the values for these come from 
092      // portlet initialization parameters in the portlet.xml
093    
094      /** A PortletContext attribute that a portlet can set prior
095       * to calling the bridge's init() method to configure the bridge to preserve
096       * action parameters received by this portlet along with bridge's request scope so
097       * that they may be restored and acessed in subsequent renders.  If "true", the
098       * action parameters are preserved.  If "false", they are not preserved.  The bridge
099       * default is "false".<br>
100       *
101       * As this attribute is scoped to a specific portlet in an application-wide context
102       * the attribute name must be include the portlet name as follows:
103       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + preserveActionParams
104       */
105      public static final String PRESERVE_ACTION_PARAMS = "preserveActionParams";
106    
107    
108      /** A PortletContext attribute that a portlet can set prior
109       * to calling the bridge's init() method to configure the bridge to exclude
110       * specific attributes from its bridge request scope. Value is a comma delimited
111       * list containing either a fully qualified attribute name or package name terminated
112       * with a ".*" wildcard indicator.  In this later case, all attributes in the package
113       * name which precedes the ".*" are excluded, non recursive.<br>
114       *
115       * As this attribute is scoped to a specific portlet in an application-wide context
116       * the attribute name must be include the portlet name as follows:
117       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + excludedRequestAttributes
118       */
119      public static final String EXCLUDED_REQUEST_ATTRIBUTES = "excludedRequestAttributes";
120    
121      /** PortletContext attribute that a portlet must set prior
122       * to calling the bridge's init() method to convey to the bridge the set of default
123       * viewIds that correspond to this portlet's supported <code>PortletMode</code>s. 
124       * Its value is a Map with one entry per mode.  The mode name is the key.  The entry's
125       * value is the corresponding default viewId the bridge should use for this mode.
126       * <br>
127       *
128       * As this attribute is scoped to a specific portlet in an application-wide context
129       * the attribute name must be include the portlet name as follows:
130       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + DEFAULT_VIEWID_MAP
131       */
132      public static final String DEFAULT_VIEWID_MAP = "defaultViewIdMap";
133      
134      /** PortletContext attribute that a portlet can set prior to calling the bridge's
135       *  init() method to configure the response class the bridge uses/sets when it
136       *  dispatches to render a portlet or a resource.  The attribute's value is expected to be a class
137       *  instance that implements <code>javax.portlet.faces.BridgeWriteBehindResponse</code>
138       *  Because the WriteBehind JSP support
139       *  is Faces implementation specific, implementations differ depending on both the 
140       *  Faces provider and its version.  Developers therefore must configure the
141       *  appropriate class for a given environment. <p>
142       *  Note: in Portlet 1.0 Bridge, because it lacked wrapper support, this behavior
143       *  was supported by using a servlet filter to wrap the response.  The bridge's 
144       *  default mechanism (i.e. when a portlet hasn't configured a specific class) 
145       *  preserves the support for such filters.  That is by default the Portlet 2.0
146       *  bridge is backwards compatible with an implementation used in a Portlet 1.0 environment.<p>
147       *  It is also important to note that the Portlet 1.0 Bridge mechanism which uses
148       *  servlet filters and the Portlet 2.0 Bridge mechanism of implementing the same 
149       *  support in a Portlet <code>ResponseWrapper<code> are unlikely to work together.
150       *  <br>
151       *
152       * As this attribute is scoped to a specific portlet in an application-wide context
153       * the attribute name must be include the portlet name as follows:
154       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + WRITE_BEHIND_RESPONSE
155       */
156      public static final String WRITE_BEHIND_RESPONSE = "writeBehindResponse";
157    
158      // The following are request attributes a portlet can set to control the request
159      // processing of the bridge.  
160    
161      /** PortletRequest attribute that a portlet may set prior
162       * to calling the bridge's doFacesRequest() method.  The value of this
163       * attribute is a <code>String</code> representing the Faces viewId the
164       * bridge is to target for this request.  Used by a portlet to specifically 
165       * control a request's view target in situations such as navigating from
166       * a nonFaces view to a specific Faces view (other than the default).<p>
167       * Generally, the use of this attribute is mutually exclusive with the use
168       * of VIEW_PATH.  If both have been set in a given request, the bridge gives
169       * precedence to VIEW_ID.
170       */
171      public static final String VIEW_ID = BRIDGE_PACKAGE_PREFIX + "viewId";
172    
173      /** PortletRequest attribute that a portlet may set prior
174       * to calling the bridge's doFacesRequest() method.  The value of this
175       * attribute is a <code>String</code> containing a <code>ContextPath</code>
176       * relative path in which the Faces viewId is encoded.  Like VIEW_ID, this
177       * attribute provides a means for a portlet to explicitly control the Faces
178       * target for a specific request.  It is used in situations such as navigating from
179       * a nonFaces view to a specific Faces view (other than the default).<p>
180       * Generally, the use of this attribute is mutually exclusive with the use
181       * of VIEW_PATH.  If both have been set in a given request, the bridge gives
182       * precedence to VIEW_ID.
183       */
184      public static final String VIEW_PATH = BRIDGE_PACKAGE_PREFIX + "viewPath";
185    
186      // Names for special QueryString parameters names the Bridge recognizes in
187      // encodeActionURL as signifying to change the corresponding portlet values
188      // in the resulting URL
189    
190      /**
191       * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
192       * that it recognizes as an indication that this action should encode a PortletMode
193       * change to the one indicated by the parameter's value.
194       */
195      public static final String PORTLET_MODE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "PortletMode";
196    
197      /**
198       * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
199       * that it recognizes as an indication that this action should encode a WindowState change to
200       * the one indicated by the parameter's value.
201       */
202      public static final String PORTLET_WINDOWSTATE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "WindowState";
203    
204      /**
205       * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
206       * that it recognizes as an indication that this action should encode a security level change to
207       * the one indicated by the parameter's value.
208       */
209      public static final String PORTLET_SECURE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "Secure";
210    
211      /**
212       * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
213       * that it recognizes as an indication that this action should be treated as a direct link
214       * and hence shouldn't be encoded as a Portlet action.  Rather encodeActionURL merely returns
215       * this url unchanged.
216       */
217      public static final String DIRECT_LINK = BRIDGE_PACKAGE_PREFIX + "DirectLink";
218      
219      /**
220       * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
221       * that it recognizes as an indication that this resource should be handled in protocol.
222       */
223      public static final String IN_PROTOCOL_RESOURCE_LINK = 
224        BRIDGE_PACKAGE_PREFIX + "InProtocolResourceLink";
225    
226      /**
227       * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
228       * that it recognizes as an indication that an URL refering back to the page which
229       * contains this portlet should be encoded in the resource url. This reference is
230       * encoded as the value of a query string parameter whose name is the value of this back
231       * link token parameter.
232       */
233      public static final String BACK_LINK = BRIDGE_PACKAGE_PREFIX + "BackLink";
234    
235      /**
236       * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
237       * that it recognizes as an indication that this url refers to Faces view (navigation) and
238       * hence should be encoded as an portlet ActionURL rather then a portlet resource url.  This token
239       * is intended for use in urls signifying a view navigation using components such as
240       * <code>h:outputLink</code>. 
241       */
242      public static final String VIEW_LINK = BRIDGE_PACKAGE_PREFIX + "ViewLink";
243    
244    
245      // Request attributes set by the bridge that can be used by Faces extensions
246      // and/or applications to properly run in a portlet environment. 
247    
248      /**
249       * A PortletRequest attribute set by the bridge when processing a Faces request
250       * that signals this request is a Faces postback.  Its provided as
251       * an alternative signal to the common reliance on the view state parameter as
252       * an indicator that this is a postback request.  Implementations needing this 
253       * information and not using the view state parameter indicator can check this 
254       * attribute when running in a portlet environment.
255       */
256      public static final String IS_POSTBACK_ATTRIBUTE = BRIDGE_PACKAGE_PREFIX + "isPostback";
257    
258      /** A PortletRequest attribute set by the bridge in its
259       * <code>ViewHandler.renderView</code> prior to dispatching the request
260       * to the view (jsp)to indicating a filter should
261       * put the AFTER_VIEW_CONTENT in a buffer on the request for it to process after
262       * rendering the view components.  In conjunction with the filter this enables
263       * preserving rendering order of native JSP rendering and Faces rendering in a jsp.
264       */
265      public static final String RENDER_CONTENT_AFTER_VIEW = 
266        BRIDGE_PACKAGE_PREFIX + "RenderContentAfterView";
267    
268      /** A PortletRequest attribute set by an include filter in recognition of the
269       * RenderContentAfterView bridge attribute.  Its value is either char[] or byte[]
270       * holding the AFTER_VIEW_CONTENT generated while rendering this jsp.
271       * In conjunction with the bridge this enables
272       * preserving rendering order of native JSP rendering and Faces rendering in a jsp.
273       */
274      public static final String AFTER_VIEW_CONTENT = BRIDGE_PACKAGE_PREFIX + "AfterViewContent";
275    
276      /** PortletRequest attribute set by the bridge prior to creating/acquiring a
277       * <code>FacesContext</code>.  Its value indicates which portlet phase this 
278       * Faces is executing in.  It can be used by Faces subsystems not only to determine
279       * the portlet exectution phase but if present (not null) as an indication the request
280       * is being processed in a portlet container.
281       */
282      public static final String PORTLET_LIFECYCLE_PHASE = BRIDGE_PACKAGE_PREFIX + "phase";
283    
284      /** PortletSession attribute set by the bridge to hold the last viewId accessed in a given mode.  
285       * The attribute (key) is composed of this name + the mode name.  I.e. 
286       * javax.portlet.faces.viewIdHistory.view.  There is one attribute per supported portlet
287       * mode.  The attributes are always set even if the user session has never entered the
288       * mode.  Its initial setting/value is determined by the default viewId configured
289       * for the mode.  Attribute is used by developers to reference/return to the last view in
290       * a given Mode from another mode.
291       */
292      public static final String VIEWID_HISTORY = BRIDGE_PACKAGE_PREFIX + "viewIdHistory";
293    
294    
295      /** Name of PortletResponse property set by the bridge when it recognizes that the 
296       * view has been rendered using a <code>NamingContainer</code> that ensures all
297       * generated ids are namespaced using the consumer provided unique portlet id.
298       */
299      public static final String PORTLET_NAMESPACED_RESPONSE_PROPERTY = 
300        "X-JAVAX-PORTLET-FACES-NAMESPACED-RESPONSE";
301    
302      /** Name of the render parameter set by the bridge when it encodes a navigation
303       *  link to a nonFaces target. Though the bridge recognizes nonFaces targets when
304       *  it encodes a navigational link, it does not handle the subsequent request. 
305       *  It only handles requests for Faces targets.  It is the portlet's responsibility
306       *  to detect and handle these requests.  When the nonFaces target is a path based
307       *  resource (such as a jsp or servlet), the <code>ContextPath</code> relative path
308       *  of the resource is written as the value of this render parameter.  For convenience,
309       *  the GenericFacesPortlet recognizes this render parameter in received requests
310       *  and uses the <code>PortletRequestDispatcher</code> to dispatch to the encoded
311       *  path instead of calling the bridge to execute the request.
312       */
313      public static final String NONFACES_TARGET_PATH_PARAMETER = "_jsfBridgeNonFacesView";
314    
315      /** Name of a request parameter (generally) encoded in a link from a nonFaces
316       *  view response.  It acts as a marker to the portlet that the nonFaces view
317       *  intends to navigate to the Faces view expressed in the value of this parameter.
318       *  It differs from the <code>FACES_VIEW_PATH_PARAMETER</code> in that its value
319       *  is the actual Faces viewId of the target while the formaer is a
320       *  <code>ContextPath</code> relative path containing the viewId.<p>
321       *  Portlets receiving such a parameter should set the the corresponding request
322       *  attribute <code>javax.portlet.faces.viewId</code> before calling the bridge
323       *  to handle the request.
324       */
325      public static final String FACES_VIEW_ID_PARAMETER = "_jsfBridgeViewId";
326    
327      /** Name of a request parameter (generally) encoded in a link from a nonFaces
328       *  view response.  It acts as a marker to the portlet that the nonFaces view
329       *  intends to navigate to the Faces view expressed in the value of this parameter.
330       *  It differs from the <code>FACES_VIEW_ID_PARAMETER</code> in that its value
331       *  is a <code>ContextPath</code> relative path containing the viewId while the former
332       *  is the viewId itself.<p>
333       *  Portlets receiving such a parameter should set the the corresponding request
334       *  attribute <code>javax.portlet.faces.viewPath</code> before calling the bridge
335       *  to handle the request.
336       */
337      public static final String FACES_VIEW_PATH_PARAMETER = "_jsfBridgeViewPath";
338    
339      /** A PortletContext attribute that a portlet can set prior
340       * to calling the bridge's init() method to configure the bridge to use/call
341       * the associated eventHandler when processing an event. Value is an instance of
342       * <code>BridgeEventHandler</code>.
343       *
344       * As this attribute is scoped to a specific portlet in an application-wide context
345       * the attribute name must be include the portlet name as follows:
346       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler
347       */
348      public static final String BRIDGE_EVENT_HANDLER = "bridgeEventHandler";
349      
350      /** A PortletContext attribute that a portlet can set prior
351       * to calling the bridge's init() method to configure the bridge to use/call
352       * the associated publicRenderParameterHandler.  This handler is used to
353       * process updates that result from public render parameter changes passed in 
354       * a request.  The bridge first pushs all the public render parameter values into the models and
355       * then calls this handler's processUpdates method.  The handler can then compute
356       * further model changes based on the changes. Value is an instance of
357       * <code>BridgePublicRenderParameterHandler</code>.
358       *
359       * As this attribute is scoped to a specific portlet in an application-wide context
360       * the attribute name must be include the portlet name as follows:
361       * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler
362       */
363      public static final String BRIDGE_PUBLIC_RENDER_PARAMETER_HANDLER = "bridgePublicRenderParameterHandler";
364      
365      /** Special value recognized during <code>encodeActionURL</code> of a portlet: url containing either
366       * the <code>_jsfBridgeViewId</code> or <code>_jsfBridgeViewPath</code> parameter. 
367       * <code>encodeActionURL</code> recognizes this value as indicating it needs to generate and
368       * encode an URL to the current JSF including its current state.  I.e. It not only
369       * encodes the link reference but also the existing render parameters so they can be carried forward
370       * to reestablish the state.
371       */
372      public static final String FACES_USE_CURRENT_VIEW_PARAMETER = "_jsfBridgeCurrentView";
373    
374    
375      /** Enumeration whose values describe the current portlet phase the bridge
376       * is executing Faces within.
377       */
378      public static enum PortletPhase
379      {
380        ACTION_PHASE,
381        RENDER_PHASE,
382        EVENT_PHASE,
383        RESOURCE_PHASE,
384        ;
385      }
386    
387      /** Enumeration whose values describe the render policy used by the bridge
388       * to render portlets in this application.  A policy of DEFAULT indicates
389       * the bridge will first delegate rendering and if this results in an
390       * exception being thrown will render the itself.  A policy of ALWAYS_DELEGATE
391       * indicates the bridge will always delegate rendering, never rendering itself.
392       * A policy of NEVER_DELEGATE indicates the bridge will always render itself without
393       * delegating.
394       */
395      public static enum BridgeRenderPolicy
396      {
397        DEFAULT,
398        ALWAYS_DELEGATE,
399        NEVER_DELEGATE,
400        ;
401      }
402    
403      /**
404       * Called by the portlet. It indicates that the bridge is being placed into service.
405       * <p>
406       * The portlet calls the <code>init</code> method exactly once before invoking other lifecycle
407       * methods. Usually, done immediately after instantiating the bridge. The <code>init</code>
408       * method must complete successfully before the bridge can receive any requests.
409       * <p>
410       * The portlet cannot place the bridge into service if the <code>init</code> method Throws a
411       * <code>BridgeException</code>.
412       * <p>
413       * Initialization context is passed to bridge via <code>PortletContext</code> attributes. The
414       * following attributes are defined:
415       * <ul>
416       * <li><code>javax.portlet.faces.encodeRedirectURL</code>: instructs the bridge to call
417       * <code>ExternalContext.encodeActionURL()</code> before processing the redirect request. This
418       * exists because some (newer) versions of JSF 1.2 call <code>encodeActionURL</code> before
419       * calling <code>redirect</code> while others do not. This flag adjusts the behavior of the
420       * bridge in accordance with the JSF 1.2 implementation it runs with.
421       * <li><code>javax.portlet.faces.numManagedActionScopes</code>: defines the maximum number of
422       * actionScopes this bridge preserves at any given time. Value is an integer. ActionScopes are
423       * managed on a per Bridge class portlet context wide basis. As a typical portlet application uses
424       * the same bridge implementation for all its Faces based portlets, this means that all
425       * actionScopes are managed in a single bucket.<br>
426       * For convenience this interface defines the <code>NUM_MANAGED_ACTIONSCOPES</code> constant.
427       * <li><code>javax.faces.lifecycleID</code>: defines the Faces <code>Lifecycle</code> id
428       * that bridge uses when acquiring the <code>Faces.Lifecycle</code> via which it executes the
429       * request. As a context wide attribute, all bridge instances in this portlet application will use
430       * this lifecyle.
431       * <li><code>javax.portlet.faces.[portlet name].preserveActionParams</code>: instructs the
432       * bridge to preserve action parameters in the action scope and represent them in subsequent
433       * renders. Should be used only when binding to a Faces implementation that relies on accessing
434       * such parameters during its render phase. As this is a portlet/bridge instance specific
435       * attribute, the <code>PortletContext</code>attribute name is qualified by the portlet
436       * instance name. This allows different portlets within the same portlet application to have
437       * different settings.<br>
438       * For convenience this interfaces defines a number of constants that simplifies constructing
439       * and/or recognizing this name.
440       * </ul>
441       * 
442       * @param config
443       *          a <code>PortletConfig</code> object containing the portlet's configuration and
444       *          initialization parameters
445       * @exception BridgeException
446       *              if an exception has occurred that interferes with the bridge's normal operation.
447       *              For example, if the bridge is already initialized.
448       * @exception UnavailableException
449       *              if the portlet cannot perform the initialization at this time.
450       */
451      public void init(PortletConfig config) throws BridgeException;
452    
453      /**
454       * Called by the portlet when it wants the bridge to process an action request.
455       * 
456       * @param request
457       *          the request object.
458       * @param response
459       *          the response object.
460       * @throws BridgeDefaultViewNotSpecifiedException
461       *           thrown if the request indicates to the Bridge that is should use the default ViewId
462       *           and the portlet hasn't supplied one.
463       * @throws BridgeUninitializedException
464       *           thrown if the bridge is not initialized.          
465       * @throws BridgeException
466       *           all other internal exceptions are converted to a BridgeException.
467       */
468      public void doFacesRequest(ActionRequest request, 
469                                 ActionResponse response) throws BridgeDefaultViewNotSpecifiedException, 
470                                                                 BridgeUninitializedException, 
471                                                                 BridgeException;
472      
473      /**
474       * Called by the portlet when it wants the bridge to process an event request.
475       * 
476       * @param request
477       *          the request object.
478       * @param response
479       *          the response object.
480       * @throws BridgeUninitializedException
481       *           thrown if the bridge is not initialized.      
482       * @throws BridgeException
483       *           all other internal exceptions are converted to a BridgeException.
484       */
485      public void doFacesRequest(EventRequest request, 
486                                 EventResponse response) throws BridgeUninitializedException, 
487                                                                   BridgeException;
488    
489    
490      /**
491       * Called by the portlet when it wants the bridge to process a render request.
492       * 
493       * @param request
494       *          the request object.
495       * @param response
496       *          the response object.
497       * @throws BridgeDefaultViewNotSpecifiedException
498       *           thrown if the request indicates to the Bridge that is should use the default ViewId
499       *           and the portlet hasn't supplied one.
500       * @throws BridgeUninitializedException
501       *           thrown if the bridge is not initialized.      
502       * @throws BridgeException
503       *           all other internal exceptions are converted to a BridgeException.
504       */
505      public void doFacesRequest(RenderRequest request, 
506                                 RenderResponse response) throws BridgeDefaultViewNotSpecifiedException, 
507                                                                 BridgeUninitializedException, 
508                                                                 BridgeException;
509    
510      /**
511       * Called by the portlet when it wants the bridge to process an in-protocol
512       * resource request.
513       * 
514       * @param request
515       *          the request object.
516       * @param response
517       *          the response object.
518       * @throws BridgeUninitializedException
519       *           thrown if the bridge is not initialized.      
520       * @throws BridgeException
521       *           all other internal exceptions are converted to a BridgeException.
522       */
523      public void doFacesRequest(ResourceRequest request, 
524                                 ResourceResponse response) throws BridgeUninitializedException, 
525                                                                   BridgeException;
526    
527      /**
528       * Called by the portlet to take the bridge out of service. Once out of service, the bridge must
529       * be reinitialized before processing any further requests.
530       */
531      public void destroy();
532    
533    }