javax.faces.event.PhaseListener Java Examples

protected void broadcastAfterEvent(PhaseEvent phaseEvent)
{
    //TODO discuss exception handling

    //fire to phase-observer methods
    this.phaseEvent.select(createAnnotationLiteral(phaseEvent.getPhaseId(), false)).fire(phaseEvent);
    this.afterAnyPhaseEvent.fire(phaseEvent);

    //fire to ds-phase-listeners
    //call the listeners in reverse-order (like jsf)
    ListIterator<PhaseListener> phaseListenerIterator = this.phaseListeners.listIterator(phaseListeners.size());

    while (phaseListenerIterator.hasPrevious())
    {
        PhaseListener phaseListener = phaseListenerIterator.previous();
        PhaseId targetPhase = phaseListener.getPhaseId();

        if (targetPhase == PhaseId.ANY_PHASE || targetPhase == phaseEvent.getPhaseId())
        {
            phaseListener.afterPhase(phaseEvent);
        }
    }
}
 

protected void broadcastBeforeEvent(PhaseEvent phaseEvent)
{
    //TODO discuss exception handling

    //fire to phase-observer methods
    this.phaseEvent.select(createAnnotationLiteral(phaseEvent.getPhaseId(), true)).fire(phaseEvent);
    this.beforeAnyPhaseEvent.fire(phaseEvent);

    //fire to ds-phase-listeners
    for (PhaseListener phaseListener : this.phaseListeners)
    {
        PhaseId targetPhase = phaseListener.getPhaseId();

        if (targetPhase == PhaseId.ANY_PHASE || targetPhase == phaseEvent.getPhaseId())
        {
            phaseListener.beforePhase(phaseEvent);
        }
    }
}
 

@Inject
protected JsfRequestLifecycleBroadcaster(Instance<PhaseListener> phaseListenerInstance)
{
    Class phaseListenerClass;
    for (PhaseListener currentPhaseListener : phaseListenerInstance)
    {
        phaseListenerClass = ProxyUtils.getUnproxiedClass(currentPhaseListener.getClass());

        if (phaseListenerClass.isAnnotationPresent(JsfPhaseListener.class))
        {
            if (Deactivatable.class.isAssignableFrom(phaseListenerClass) &&
                !ClassDeactivationUtils.isActivated(phaseListenerClass))
            {
                continue;
            }
            this.phaseListeners.add(currentPhaseListener);
        }
    }

    //higher ordinals first
    sortDescending(this.phaseListeners);
}
 

public PhaseListener getListener() {
    return new PhaseListener() {
        private static final long serialVersionUID = -66585096775189540L;

        public PhaseId getPhaseId() {
            return PhaseId.RENDER_RESPONSE;
        }

        public void beforePhase(PhaseEvent event) {
            unselectCategory();
        }

        public void afterPhase(PhaseEvent arg0) {
            // nothing
        }
    };
}
 

private static void sortDescending(List<PhaseListener> phaseListeners)
{
    Collections.sort(phaseListeners, new Comparator<PhaseListener>()
    {
        @Override
        public int compare(PhaseListener phaseListener1, PhaseListener phaseListener2)
        {
            return (phaseListener1.getClass().getAnnotation(JsfPhaseListener.class).ordinal() >
                    phaseListener2.getClass().getAnnotation(JsfPhaseListener.class).ordinal()) ? -1 : 1;
        }
    });
}
 

public void listAllPhaseListeners() {
	LifecycleFactory lifecycleFactory = (LifecycleFactory) FactoryFinder
			.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
	Lifecycle applicationLifecycle = lifecycleFactory
			.getLifecycle(LifecycleFactory.DEFAULT_LIFECYCLE);

	PhaseListener phaseListeners[] = applicationLifecycle
			.getPhaseListeners();
	for (PhaseListener phaseListener : phaseListeners) {
		System.out.println(phaseListener.getPhaseId());
	}
}
 

@Override
public void addPhaseListener(PhaseListener listener) {
    if (firstPhaseListener) {
        //forced order independent of any other config
        firstPhaseListener = false;
        wrapped.addPhaseListener(new ExtValStartupListener());
    }
    wrapped.addPhaseListener(listener);
}
 

@Override
public void removePhaseListener(PhaseListener phaseListener) {
}
 

@Override
public PhaseListener[] getPhaseListeners() {
	return null;
}
 

@Override
public void addPhaseListener(PhaseListener newPhaseListener) {
    throw new UnsupportedOperationException();
}
 

@Override
public void removePhaseListener(PhaseListener toRemove) {
    throw new UnsupportedOperationException();
}
 

@Override
public void removePhaseListener(PhaseListener listener) {
    throw new NotImplementedException();
}
 

@Override
public PhaseListener[] getPhaseListeners() {
    throw new NotImplementedException();
}
 

@Override
public void addPhaseListener(PhaseListener listener) {
    throw new NotImplementedException();
}
 

@Override
public PhaseListener[] getPhaseListeners() {
    return wrapped.getPhaseListeners();
}
 

@Override
public void removePhaseListener(PhaseListener listener) {
    wrapped.removePhaseListener(listener);
}
 

@Override
public void addPhaseListener(PhaseListener phaseListener)
{
    this.wrapped.addPhaseListener(phaseListener);
}
 

@Override
public PhaseListener[] getPhaseListeners()
{
    return this.wrapped.getPhaseListeners();
}
 

@Override
public void removePhaseListener(PhaseListener phaseListener)
{
    this.wrapped.removePhaseListener(phaseListener);
}
 

@Override
public PhaseListener[] getPhaseListeners() {
	return null;
}
 

@Override
public void afterPhase(PhaseEvent event) {
	for (PhaseListener listener : getDelegates(event.getFacesContext())) {
		listener.afterPhase(event);
	}
}
 

@Override
public void addPhaseListener(PhaseListener phaseListener) {
}
 

@Override
public PhaseListener[] getPhaseListeners() {
	return null;
}
 

@Override
public void removePhaseListener(PhaseListener phaseListener) {
}
 

@Override
public void beforePhase(PhaseEvent event) {
	for (PhaseListener listener : getDelegates(event.getFacesContext())) {
		listener.beforePhase(event);
	}
}
 

@Override
public void afterPhase(PhaseEvent event) {
	for (PhaseListener listener : getDelegates(event.getFacesContext())) {
		listener.afterPhase(event);
	}
}
 

@Override
public void addPhaseListener(PhaseListener phaseListener) {
}
 

@Override
public void beforePhase(PhaseEvent event) {
	for (PhaseListener listener : getDelegates(event.getFacesContext())) {
		listener.beforePhase(event);
	}
}
 

@Override
public void removePhaseListener(PhaseListener phaseListener) {
}
 

@Override
public void beforePhase(PhaseEvent event) {
	for (PhaseListener listener : getDelegates(event.getFacesContext())) {
		listener.beforePhase(event);
	}
}