com.sun.faces.application.view.ViewHandlingStrategy Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jakarta.faces Show documentation
EE4J Compatible Implementation for Jakarta Faces API
The newest version!
/*
 * Copyright (c) 1997, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package com.sun.faces.application.view;

import static com.sun.faces.util.Util.getFacesMapping;
import static com.sun.faces.util.Util.notNull;
import static jakarta.faces.component.UIViewRoot.COMPONENT_TYPE;
import static jakarta.servlet.http.MappingMatch.PATH;
import static java.util.logging.Level.FINE;

import java.io.IOException;
import java.util.Locale;
import java.util.logging.Logger;

import com.sun.faces.application.ApplicationAssociate;
import com.sun.faces.config.WebConfiguration;
import com.sun.faces.util.FacesLogger;

import jakarta.faces.FacesException;
import jakarta.faces.application.ViewHandler;
import jakarta.faces.component.UIViewRoot;
import jakarta.faces.context.ExternalContext;
import jakarta.faces.context.FacesContext;
import jakarta.faces.view.ViewDeclarationLanguage;

/**
 * 
 * This represents how a particular page description language is to be rendered/restored.
 * 
 */
public abstract class ViewHandlingStrategy extends ViewDeclarationLanguage {

    private static final Logger logger = FacesLogger.APPLICATION.getLogger();

    protected ApplicationAssociate associate;
    protected WebConfiguration webConfig;

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

    public ViewHandlingStrategy() {
        FacesContext ctx = FacesContext.getCurrentInstance();
        webConfig = WebConfiguration.getInstance(ctx.getExternalContext());
        associate = ApplicationAssociate.getInstance(ctx.getExternalContext());
    }

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

    /**
     * @see ViewDeclarationLanguage#restoreView(jakarta.faces.context.FacesContext, String)
     */
    @Override
    public UIViewRoot restoreView(FacesContext ctx, String viewId) {
        ExternalContext extContext = ctx.getExternalContext();

        if (extContext.getRequestPathInfo() == null && getFacesMapping(ctx).getMappingMatch() == PATH) {
            // This was probably an initial request.
            // Send them off to the root of the web application.
            try {
                ctx.responseComplete();
                logger.log(FINE, () -> "Response Complete for" + viewId);
                if (!extContext.isResponseCommitted()) {
                    extContext.redirect(extContext.getRequestContextPath());
                }
            } catch (IOException ioe) {
                throw new FacesException(ioe);
            }

            return null;
        }

        ViewHandler viewHandler = ctx.getApplication().getViewHandler();

        // This is necessary to allow decorated implementations.
        return viewHandler.getViewDeclarationLanguage(ctx, viewId)
                          .getStateManagementStrategy(ctx, viewId)
                          .restoreView(ctx, viewId, viewHandler.calculateRenderKitId(ctx));
    }

    /**
     * @see ViewDeclarationLanguage#createView(jakarta.faces.context.FacesContext, String)
     */
    @Override
    public UIViewRoot createView(FacesContext ctx, String viewId) {
        notNull("context", ctx);

        UIViewRoot result = (UIViewRoot) ctx.getApplication().createComponent(COMPONENT_TYPE);

        Locale locale = null;
        String renderKitId = null;

        // use the locale from the previous view if is was one which will be
        // the case if this is called from NavigationHandler. There wouldn't be
        // one for the initial case.
        if (ctx.getViewRoot() != null) {
            locale = ctx.getViewRoot().getLocale();
            renderKitId = ctx.getViewRoot().getRenderKitId();
        }

        if (logger.isLoggable(FINE)) {
            logger.log(FINE, "Created new view for " + viewId);
        }

        // PENDING(): not sure if we should set the RenderKitId here.
        // The UIViewRoot ctor sets the renderKitId to the default
        // one.
        // If there was no locale from the previous view, calculate the locale for this view.
        if (locale == null) {
            locale = ctx.getApplication().getViewHandler().calculateLocale(ctx);
            if (logger.isLoggable(FINE)) {
                logger.fine("Locale for this view as determined by calculateLocale " + locale.toString());
            }
        } else {
            if (logger.isLoggable(FINE)) {
                logger.fine("Using locale from previous view " + locale.toString());
            }
        }

        if (renderKitId == null) {
            renderKitId = ctx.getApplication().getViewHandler().calculateRenderKitId(ctx);

            if (logger.isLoggable(FINE)) {
                logger.fine("RenderKitId for this view as determined by calculateRenderKitId " + renderKitId);
            }
        } else {
            if (logger.isLoggable(FINE)) {
                logger.fine("Using renderKitId from previous view " + renderKitId);
            }
        }

        result.setLocale(locale);
        result.setRenderKitId(renderKitId);
        result.setViewId(viewId);

        return result;
    }

    /**
     *
     * @param viewId the view ID
     * @return true if this ViewHandlingStrategy handles the the view type represented by
     * viewId
     */
    public abstract boolean handlesViewId(String viewId);

}