Question

I have a class which is used to generate navigation from a variety of interconnected bundles. I have a Navigation service to accomplish this.

In order to connect this service with the other bits of Navigation, I want to allow the other bundles to define their own services which then listen to the event listener and add their navigation items at the proper time.

The problem is, I can’t figure out how to have a service listen to an event without first calling that service manually in order to create it.

Any ideas?

---

To give a more concrete idea, I have something like this:

// Set up as a service in the bundle.
class Navigation {
    // ...
    protected $dispatcher; // event dispatcher passed in to service

    // ...
    public function generateNavigation() {
        $items = array();
        // add some items

        $event = new NavigationEvent($items); // custom event
        $this->eventDispatcher->dispatchEvent('navigation_event', $event);
    }
}

// Set up as a service in some secondary bundle.
class NavigationWorker {
    /**
     * @param $dispatcher Same instance as Navigation
     */
    public function __construct(EventDispatcher $dispatcher) {
        $dispatcher->addListener('navigation_event', array($this, 'doSomething'));
    }
}

With this set up, it should work if the NavigationWorker is called at some point and is constructed, but I can’t always call them directly, so it is never constructed and the listener is never added.

The way I currently do it is to pass all of the NavigationWorkers to Navigation and have it add their listener, but this is very ugly.

Answer 1

I’m changing the answer to this because while that set me on the right path, it wasn’t the complete answer. That article really only allows you to hook in to pre-defined kernel events. I however needed my own, so I started working back from there.

In the end, I ended up creating my own tags, a compiler pass to process those tasks. I also added my own extension of EventDispatcher, though that wasn’t super-necessary (you could just use the normal one).

Here is what the file solution looked like.

Configuration:

parameters:
    my_bundle.navigation.event.class: My\Bundle\DependencyInjection\NavigationEvent

    my_bundle.event_dispatcher.class: My\Bundle\DependencyInjection\EventDispatcher
    my_bundle.navigation.class: My\Bundle\DependencyInjection\NavigationGenerator
    my_bundle.navigation_listener1.class: My\Bundle\DependencyInjection\NavigationListener
    my_bundle.navigation_listener2.class: My\Bundle\DependencyInjection\NavigationListener

services:
    my_bundle.event_dispatcher:
        class: %my_bundle.event_dispatcher.class%
    my_bundle.navigation:
        class: %my_bundle.navigation.class%
        arguments:
            - @my_bundle.event_dispatcher
    my_bundle.navigation_listener1.class:
        class: %my_bundle.navigation_listener1.class%
        tags:
            - { name: my_bundle.event_listener, event: my_bundle.navigation.generate, method: onGenerateNavigation }
    my_bundle.navigation_listener2.class:
        class: %my_bundle.navigation_listener2.class%
        tags:
            - { name: my_bundle.event_listener, event: my_bundle.navigation.generate, method: onGenerateNavigation }

CompilerPass:

use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\Reference;

class EventListenerCompilerPass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container)
    {
        if (!$container->hasDefinition('my_bundle.event_dispatcher')) {
            return;
        }

        $definition = $container->getDefinition(
            'my_bundle.event_dispatcher'
        );

        $taggedServices = $container->findTaggedServiceIds(
            'my_bundle.event_listener'
        );

        foreach ($taggedServices as $id => $tagAttributes) {
            foreach ($tagAttributes as $attributes) {
                $definition->addMethodCall(
                    'addListener',
                    array($this->getEventString($attributes['event'], $container),     array(new Reference($id), $attributes['method']))
                );
            }
        }
    }

protected function getEventString($str, ContainerBuilder $container)
{
    preg_match('/(.*)\.([^.]*)$/', $str, $matches);
    $parameterName = $matches[1];
    $constName = strtoupper($matches[2]);

    $eventClass = $container->getParameter($parameterName . '.event.class');

    if (!$eventClass) {
        throw new Exception('Unable to find parameter: ' . $eventClass . '.event.class');
    }

    // Return the value of the constant.
    return constant($eventClass . '::' . $constName);
}

Add a function like this to your compiler class (something like MyBundleBundle).

public function build(ContainerBuilder $container)
{
    parent::build($container);

    $container->addCompilerPass(new EventListenerCompilerPass());
}

Now the EventListener will have added listeners for each of those events. You than just implement everything else exactly as you would expect (Navigation dispatches events which it listens too). You can than hook in new event listeners from any bundle, and they don’t even need to share a common class/interface.

This also works for any custom event, as long as the object which has the constant for the event is registered in the parameters with “.event.class” at the end (so my_bundle.navigation.generate looks for the parameter my_bundle.navigation.event.class, uses that class and the constant GENERATE).

Hopefully that’ll help anyone else looking to do something similar.