The key, in the session's attribute set, under which the response character encoding may be stored and retrieved.

Allow the web application to define an alternate suffix for pages containing JSF content. If this init parameter is not specified, the default value is taken from the value of the constant #DEFAULT_SUFFIX .

The value to use for the default extension if the webapp is using url extension mapping.

 public String calculateCharacterEncoding(FacesContext context) 
{
    // ---------------------------------------------------------- Public Methods
         ExternalContext extContext = context.getExternalContext();
         Map< String,String > headerMap = extContext.getRequestHeaderMap();
         String contentType = headerMap.get("Content-Type");
         String charEnc = null;
         // look for a charset in the Content-Type header first.
         if (null != contentType) {
             // see if this header had a charset
             String charsetStr = "charset=";
             int len = charsetStr.length();
             int idx = contentType.indexOf(charsetStr);
             // if we have a charset in this Content-Type header AND it
             // has a non-zero length.
             if (idx != -1 && idx + len <  contentType.length()) {
                 charEnc = contentType.substring(idx + len);
             }
         }
         // failing that, look in the session for a previously saved one
         if (null == charEnc) {
             if (null != extContext.getSession(false)) {
                 charEnc = (String) extContext.getSessionMap().get
                         (ViewHandler.CHARACTER_ENCODING_KEY);
             }
         }
         return charEnc;
}

Returns the correct character encoding to be used for this request.

The following algorithm is employed.

• Examine the Content-Type request header. If it has a charset parameter, extract it and return that as the encoding.

• If no charset parameter was found, check for the existence of a session by calling ExternalContext#getSession(boolean) passing false as the argument. If that method returns true, get the session Map by calling ExternalContext#getSessionMap and look for a value under the key given by the value of the symbolic constant ViewHandler#CHARACTER_ENCODING_KEY . If present, return the value, converted to String.

• Otherwise, return null

 abstract public Locale calculateLocale(FacesContext context)
Returns an appropriate Locale  to use for this and
subsequent requests for the current client.

 abstract public String calculateRenderKitId(FacesContext context)
Return an appropriate renderKitId for this and
subsequent requests from the current client. It is an error for
this method to return null.

The default return value is javax.faces.render.RenderKitFactory#HTML_BASIC_RENDER_KIT .

 abstract public UIViewRoot createView(FacesContext context,
    String viewId)
Create and return a new UIViewRoot  instance
initialized with information from the argument
FacesContext and viewId.

If there is an existing ViewRoot available on the
FacesContext , this method must copy its
locale and renderKitId to this new view
root. If not, this method must call #calculateLocale  and
#calculateRenderKitId , and store the results as the
values of the locale and renderKitId,
proeprties, respectively, of the newly created
UIViewRoot.

 abstract public String getActionURL(FacesContext context,
    String viewId)
Return a URL suitable for rendering (after optional encoding
performed by the encodeActionURL() method of
ExternalContext ) that selects the specified view identifier.

 abstract public String getResourceURL(FacesContext context,
    String path)
Return a URL suitable for rendering (after optional encoding
perfomed by the encodeResourceURL() method of
ExternalContext ) that selects the specifed web application
resource. If the specified path starts with a slash, it must be
treated as context relative; otherwise, it must be treated as relative
to the action URL of the current view.

 public  void initView(FacesContext context) throws FacesException 
{
        String encoding = calculateCharacterEncoding(context);
        if (null != encoding) {
            try {
                context.getExternalContext().setRequestCharacterEncoding(encoding);
            } catch (UnsupportedEncodingException e) {
                // PENDING(edburns): I18N
                String message = "Can't set encoding to: " + encoding +
                        " Exception:" + e.getMessage();
                if (log.isLoggable(Level.WARNING)) {
                    log.fine(message);
                }
                throw new FacesException(message, e);
            }
        }
}

Initialize the view for the request processing lifecycle.

This method must be called at the beginning of the Restore View Phase of the Request Processing Lifecycle. It is responsible for performing any per-request initialization necessary to the operation of the lifycecle.

The default implementation calls #calculateCharacterEncoding and passes the result, if non-null into the ExternalContext#setRequestCharacterEncoding method.

 abstract public  void renderView(FacesContext context,
    UIViewRoot viewToRender) throws IOException, FacesException
Perform whatever actions are required to render the response
view to the response object associated with the
current FacesContext .

 abstract public UIViewRoot restoreView(FacesContext context,
    String viewId)
Perform whatever actions are required to restore the view
associated with the specified FacesContext  and
viewId. It may delegate to the restoreView
of the associated StateManager  to do the actual work of
restoring the view. If there is no available state for the
specified viewId, return null.

 abstract public  void writeState(FacesContext context) throws IOException
Take any appropriate action to either immediately
write out the current state information (by calling
StateManager#writeState , or noting where state information
should later be written.