Events, and Event Subscribers

Drupal 8 provides a powerful and performance efficient way how modules can interact with each other.( I.e we can fire any custom code on a perticular action like, when save configuration of site name etc fire my  custom code etc )

Modules can either dispatch events, subscribe to events, or both.

 Subscribing to an event allows a module to declare that it would like to be
 notified anytime a specific event happens. A module can subscribe to any

 number of events, and can even subscribe to the same event more than once.

 Dispatching an event allows a module, or Drupal core subsystem, to notify any
 registered subscribers that a specific event has just taken place. When an
 event is dispatched the registered code for each subscriber is executed. For
 example, whenever a configuration entity is updated the Configuration API

 dispatches a new event allowing all subscribers to react to the change.

 Subscribing to an event requires:

 * - Defining a service in your module, tagged with 'event_subscriber'.
 * - Defining a class for your subscriber service that implements
    \Symfony\Component\EventDispatcher\EventSubscriberInterface
 * - Using the getSubscribedEvents method to return a list of the events you
     want to subscribe to, and which methods on the class should be called for
     each one.

 * Dispatching an event requires:
 * - Defining a new static class with constants for unique event names and documentation. Example: \Drupal\events_exampl\Event\IncidentEvents
 * - Defining an event class that extends
    \Symfony\Component\EventDispatcher\Event
    Example: \Drupal\events_example\Event\IncidentReportEvent
 * - Use the 'event_dispatcher' service in your code to dispatch an event and   provide an event object as an argument. Example:
 *   \Drupal\events_example\Form\EventsExampleForm::submitForm()

This Document is based on example module of event_example::

There are two things Events And subscribers:

Events :  How to define your own Event in Drupal 8 : 

Create a file within event folder(folder is optional) like

/src/Event/IncidentReportEvent.php

 use Symfony\Component\EventDispatcher\Event;  
 class IncidentReportEvent extends Event {  
 }  

with in this class we create the construct method with two arguments __construct($type, $report) We send these arguments when create instance and subscribe the event in form submit function, 

EventSubscriber:

/src/EventSubscriber/EventsExampleSubscriber.php

 class EventsExampleSubscriber implements EventSubscriberInterface {  
 }  

With in the class add method getSubscribedEvents, and return the array where keys are events and values would be callback methods.

Now Event and subscribers are done, 

How to call the Subscribe the event , i.e when it will fire:

1 - There are two methods 1 is to call by services
When dispatching, or triggering, an event start by constructing a new

 $dispatcher = \Drupal::service('event_dispatcher'); 

$event = new ExampleEvent($form_state->getValue('name'));//event class instance 

$dispatcher->dispatch(ExampleEvent::SUBMIT, $event);  

2 - With in the form create a construct function with dependency injection of event dispatcher

public function __construct(EventDispatcherInterface $event_dispatcher) {
}
and also add the create function to load the additional services:

 public static function create(ContainerInterface $container) {
    // Instantiates this form class.
    return new static(
      // Load the service required to construct this class.
      $container->get('current_user')
    );
  }

The create method is a factory method that returns a new instance of the class_name object.class_name::create loads one or more services. This can be any core service, defined in core.services.yml or any *.services.yml file.

Firstly Create method runs , Beause it's factory method and it loads the services, and then fire the construct method with the same arguments , with in construct method we can get the value of servies variable.


ref : https://www.drupal.org/docs/8/api/services-and-dependency-injection/dependency-injection-for-a-form