<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
                 version="2.4">
            ...
            <!-- This is optional parameters for a facelets based application -->
            <context-param>
                <param-name>org.ajax4jsf.VIEW_HANDLERS</param-name>
                <param-value>org.jboss.portletbridge.application.FaceletPortletViewHandler</param-value>
            </context-param>

             <context-param>
                <param-name>javax.portlet.faces.RENDER_POLICY</param-name>
                <param-value>
                    ALWAYS_DELEGATE
                </param-value>
            </context-param>
            ...
        </web-app>

        <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
                 version="2.4">

             <context-param>
                <param-name>javax.portlet.faces.renderPolicy</param-name>
                <param-value>
                    NEVER_DELEGATE
                </param-value>
            </context-param>
            ...
        </web-app>

Just like with any portlet 2.0 event consumer and receiver, you must define them in the portlet.xml. To see a working example, checkout the Seam Booking Demo portlet. http://anonsvn.jboss.org/repos/portletbridge/tags/2.0.0.CR1/examples/seam/booking/

You must also define the following init params in your portlet.xml.

	<init-param>
	   <name>javax.portlet.faces.autoDispatchEvents</name>
	   <value>true</value>
	</init-param>
	<init-param>
	   <name>javax.portlet.faces.bridgeEventHandler</name>
	   <value>org.foo.eventhandler</value>
	</init-param>

For now, you must dipatch the event in the JSF or Seam backing bean. Future versions on the 2.0 bridge will automate the dispatching and consuming of events.

   if (response instanceof StateAwareResponse) {
        StateAwareResponse stateResponse = (StateAwareResponse) response;
        stateResponse.setEvent(Foo.QNAME, new Bar());
    }

Then you must also create the event handler class by implementing the BridgeEventHandler interface to process the event payload.

   public class BookingEventHandler implements BridgeEventHandler
    {
       public EventNavigationResult handleEvent(FacesContext context, Event event)
       {
            //process event payload here
       }

    }

Public Render Parameters (or PRPs) are one of the most powerful and simple Portlet 2.0 features. Several portlets (JSF or not) can share the same render parameters. This feature can be use to present a cohesive UI to the user across all portlets on the page (i.e. using an employee ID to display relative data).

The bridge maps a render parameter to a backing bean using settings in your faces-config.xml and portlet.xml. A clear and working example can be found in the Seam Booking Demo portlet. http://anonsvn.jboss.org/repos/portletbridge/tags/2.0.0.CR1/examples/seam/booking/

You must define the following init params in your portlet.xml.

    <init-param>
      <name>javax.portlet.faces.bridgePublicRenderParameterHandler</name>
      <value>org.foo.PRPHandler</value>
    </init-param>
    ...
    <supported-public-render-parameter>myCoolPRP</supported-public-render-parameter>

Create a managed bean and public-parameter-mappings in your faces-config.xml. This should be a basic bean that you can bind the passed parameter to a string with getter and setter.

     <managed-bean>
        <managed-bean-name>bookingPRP</managed-bean-name>
        <managed-bean-class>your.class.Name</managed-bean-class>
        <managed-bean-scope>session</managed-bean-scope>
    </managed-bean>

    <application>
       <application-extension>
          <bridge:public-parameter-mappings>
             <bridge:public-parameter-mapping>
                <parameter>"the name of your portlet":hotelName</parameter>
                <model-el>#{bookingPRP.hotelName}</model-el>
              </bridge:public-parameter-mapping>
           </bridge:public-parameter-mappings>
        </application-extension>
    </application>

You must set the parameter in the JSF or Seam backing bean, if you are providing one from your portlet.

   if (response instanceof StateAwareResponse) {
        StateAwareResponse stateResponse = (StateAwareResponse) response;
        stateResponse.setRenderParameter("hotelName",selectedHotel.getName());
    }

Then you must also implement the BridgePublicRenderParameterHandler interface to process any updates from the received parameter.

   public void processUpdates(FacesContext context)
   {
      ELContext elContext = context.getELContext();
      BookingPRPBean bean = (BookingPRPBean) elContext.getELResolver().getValue(elContext, null, "bookingPRP");

    if(null != bean){
       //Do something with bean.getHotelName());
    } else {

    }
   }

We have setup a few examples to show you how to use EL and a simple bean that will allow you to use the portlet resource serving mechanism within a JSF portlet.

In ResourceBean.java, you can see a very simple implementations of a Map object that uses the bridge to get and encode a resource url served from the portlets web application.

So, when you have the normal "/images", "/styles" and other resource folders in your web app, you can use the following EL expression to serve them in your JSF application.

    #{resource['/img/the-path-to-my-image.png']}

Just copy the ResourceBean.java code above, and add an entry to you faces-config.xml for the bean:

    <managed-bean>
      <managed-bean-name>resource</managed-bean-name>
      <managed-bean-class>org.richfaces.demo.common.ResourceBean</managed-bean-class>
      <managed-bean-scope>application</managed-bean-scope>
     </managed-bean>