2009/05/20 - Apache Shale has been retired.

 /*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to you under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.shale.remoting.faces;

 import java.io.OutputStream;

 import java.io.Writer;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import javax.faces.FacesException;

 import javax.faces.FactoryFinder;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.FacesContext;

 import javax.faces.context.ResponseStream;

 import javax.faces.context.ResponseWriter;

 import javax.faces.render.RenderKit;

 import javax.faces.render.RenderKitFactory;

 import javax.servlet.http.HttpServletResponse;

 /**

  * <p>Factory class for returning <code>ResponseStream</code> or

  * <code>ResponseWriter</code> instances that may be used to produce output

  * response content that is independent of whether we are running in a servlet

  * or portlet environment.  The <code>RenderKit</code> for the current request

  * will be used to manufacture stream or writer instances, if necessary.</p>

  */

 public class ResponseFactory {

     // ------------------------------------------------------------ Constructors

     // ---------------------------------------------------------- Public Methods

     /**

      * <p>Return the configured <code>ResponseStream</code> for the current

      * request, creating and installing a new one if necessary.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param contentType Content type to be set on the response,

      *  or <code>null</code> to let this be defaulted

      */

     public ResponseStream getResponseStream(FacesContext context, String contentType) {

         ResponseStream stream = context.getResponseStream();

         if (stream == null) {

             stream = createResponseStream(context, contentType);

             context.setResponseStream(stream);

         }

         return stream;

     }

     /**

      * <p>Return the configured <code>ResponseWriter</code> for the current

      * request, creating and installing a new one if necessary.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param contentType Content type to be set on the response,

      *  or <code>null</code> to let this be defaulted

      */

     public ResponseWriter getResponseWriter(FacesContext context, String contentType) {

         ResponseWriter writer = context.getResponseWriter();

         if (writer == null) {

             writer = createResponseWriter(context, contentType);

             context.setResponseWriter(writer);

         }

         return writer;

     }

     // ------------------------------------------------------- Protected Methods

     /**

      * <p>Create a new <code>ResponseStream</code> that writes to the servlet

      * or portlet response stream for the current request.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param contentType Content type to be set on the response,

      *  or <code>null</code> to let this be defaulted

      *

      * @exception IllegalStateException if a writer for the current response

      *  has already been acquired

      */

     protected ResponseStream createResponseStream(FacesContext context, String contentType) {

         Object response = context.getExternalContext().getResponse();

         // Set the content type (if specified)

         if (contentType != null) {

             try {

                 Method method =

                   response.getClass().getMethod("setContentType",

                                                 new Class[] { String.class });

                 method.invoke(response, new Object[] { contentType });

             } catch (IllegalAccessException e) {

                 throw new FacesException(e);

             } catch (InvocationTargetException e) {

                 throw new FacesException(e);

             } catch (NoSuchMethodException e) {

                 throw new FacesException(e);

             }

         }

         // Acquire the output stream we will be wrapping

         final OutputStream stream;

         try {

             String methodName =

               (response instanceof HttpServletResponse) ? "getOutputStream" : "getPortletOutputStream";

             Method method =

               response.getClass().getMethod(methodName, new Class[] { });

             stream = (OutputStream) method.invoke(response, new Object[] { });

         } catch (IllegalAccessException e) {

             throw new FacesException(e);

         } catch (InvocationTargetException e) {

             throw new FacesException(e);

         } catch (NoSuchMethodException e) {

             throw new FacesException(e);

         }

         // Construct a ResponseStream that wraps this stream

         return renderKit(context).createResponseStream(stream);

     }

     /**

      * <p>Create a new <code>ResponseWriter</code> that writes to the servlet

      * or portlet response writer for the current request.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      * @param contentType Content type to be set on the response,

      *  or <code>null</code> to let this be defaulted

      *

      * @exception IllegalStateException if a writer for the current response

      *  has already been acquired

      */

     protected ResponseWriter createResponseWriter(FacesContext context, String contentType) {

         Object response = context.getExternalContext().getResponse();

         // Set the content type (if specified)

         if (contentType != null) {

             try {

                 Method method =

                   response.getClass().getMethod("setContentType",

                                                 new Class[] { String.class });

                 method.invoke(response, new Object[] { contentType });

             } catch (IllegalAccessException e) {

                 throw new FacesException(e);

             } catch (InvocationTargetException e) {

                 throw new FacesException(e);

             } catch (NoSuchMethodException e) {

                 throw new FacesException(e);

             }

         }

         // Acquire the writer we will be wrapping

         final Writer writer;

         try {

             String methodName = "getWriter";

             Method method =

               response.getClass().getMethod(methodName, new Class[] { });

             writer = (Writer) method.invoke(response, new Object[] { });

         } catch (IllegalAccessException e) {

             throw new FacesException(e);

         } catch (InvocationTargetException e) {

             throw new FacesException(e);

         } catch (NoSuchMethodException e) {

             throw new FacesException(e);

         }

         // From JSF 1.2 on, we can call ExternalContext.getResponseCharacterEncoding(),

         // but for JSF 1.1 we must use response.getCharacterEncoding() instead

         String encoding = null;

         try {

             String methodName = "getCharacterEncoding";

             Method method =

                 response.getClass().getMethod(methodName, new Class[] { });

             encoding = (String) method.invoke(response, new Object[] { });

         } catch (IllegalAccessException e) {

             throw new FacesException(e);

         } catch (InvocationTargetException e) {

             throw new FacesException(e);

         } catch (NoSuchMethodException e) {

             throw new FacesException(e);

         }

         // Construct a ResponseWriter that wraps this stream

         if ((contentType != null) && contentType.startsWith("text/html")) {

             return renderKit(context).createResponseWriter(writer, contentType, encoding);

         } else {

             return new BasicResponseWriter(writer, contentType, encoding);

         }

     }

     /**

      * <p>Return the relevant <code>RenderKit</code> to construct response

      * stream or writer instances for this request.  If there is no render kit

      * identified yet, the default <code>RenderKit</code> will be returned.</p>

      *

      * @param context <code>FacesContext</code> for the current request

      */

     protected RenderKit renderKit(FacesContext context) {

         // Identify the RenderKit we will use to create instances

         String renderKitId = null;

         UIViewRoot root = context.getViewRoot();

         if (root != null) {

             renderKitId = root.getRenderKitId();

         }

         if (renderKitId == null) {

             renderKitId = RenderKitFactory.HTML_BASIC_RENDER_KIT;

         }

         // Return an instance of the requested RenderKit

         RenderKitFactory factory = (RenderKitFactory)

           FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);

         return factory.getRenderKit(context, renderKitId);

     }

 }