Post `PluginState.UNLOADED` event when plugins are unloaded (#567)

pf4j/src/main/java/org/pf4j/AbstractPluginManager.java

         }
 
         // remove the plugin
+        pluginWrapper.setPluginState(PluginState.UNLOADED);
         plugins.remove(pluginId);
         getResolvedPlugins().remove(pluginWrapper);
         getUnresolvedPlugins().remove(pluginWrapper);

pf4j/src/main/java/org/pf4j/PluginState.java

  * <p>
  * Lifecycle of a plugin:
  * <pre>
- * CREATED -> RESOLVED -> STARTED -> STOPPED
+ * CREATED -> RESOLVED -> STARTED -> STOPPED -> UNLOADED
  * CREATED -> DISABLED
  * CREATED -> FAILED
  *
     /**
      * Plugin failed to start.
      */
-    FAILED("FAILED");
+    FAILED("FAILED"),
+
+    /**
+     * The plugin has been unloaded. After this event has been completed, the plugin's
+     * {@link ClassLoader} will be closed.
+     */
+    UNLOADED("UNLOADED"),
+    ;
 
     private final String status;
 

pf4j/src/test/java/org/pf4j/DefaultPluginManagerTest.java

 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
     private DefaultPluginDescriptor pluginDescriptor;
     private PluginWrapper pluginWrapper;
 
+    private List<PluginStateEvent> receivedEvents;
+
     @TempDir
     Path pluginsPath;
 
     @BeforeEach
     public void setUp() throws IOException {
+        receivedEvents = new ArrayList<>();
+
         pluginManager = new DefaultPluginManager(pluginsPath);
+        pluginManager.addPluginStateListener(event -> receivedEvents.add(event));
 
         pluginDescriptor = new DefaultPluginDescriptor();
         pluginDescriptor.setPluginId("myPlugin");
         pluginManager = null;
         pluginDescriptor = null;
         pluginWrapper = null;
+        receivedEvents = null;
     }
 
     @Test
 
         PluginManager pluginManager = new DefaultPluginManager(pluginsPath) {
 
+            @Override
             protected PluginStatusProvider createPluginStatusProvider() {
                 return statusProvider;
             }
         assertTrue(deleted);
 
         assertFalse(pluginZip.file().exists());
+
+        Optional<PluginStateEvent> unloadedEvent = receivedEvents.stream()
+            .filter(event -> event.getPluginState() == PluginState.UNLOADED)
+            .findFirst();
+
+        assertTrue(unloadedEvent.isPresent());
     }
 
     @Test
         assertTrue(deleted);
 
         assertFalse(pluginJar.file().exists());
+
+        Optional<PluginStateEvent> unloadedEvent = receivedEvents.stream()
+            .filter(event -> event.getPluginState() == PluginState.UNLOADED)
+            .findFirst();
+
+        assertTrue(unloadedEvent.isPresent());
     }
 
     @Test
         assertThrows(DependencyResolver.CyclicDependencyException.class, () -> pluginManager.loadPlugins());
     }
 
+    @Test
+    public void deleteZipPluginForPluginThatHasNotBeenStartedPostsUnloadedEvent() throws Exception {
+        PluginZip pluginZip = new PluginZip.Builder(pluginsPath.resolve("my-plugin-1.2.3.zip"), "myPlugin")
+            .pluginVersion("1.2.3")
+            .build();
+
+        pluginManager.loadPlugin(pluginZip.path());
+
+        assertEquals(1, pluginManager.getPlugins().size());
+
+        boolean deleted = pluginManager.deletePlugin(pluginZip.pluginId());
+        assertTrue(deleted);
+
+        assertFalse(pluginZip.file().exists());
+
+        Optional<PluginStateEvent> unloadedEvent = receivedEvents.stream()
+            .filter(event -> event.getPluginState() == PluginState.UNLOADED)
+            .findFirst();
+
+        assertTrue(unloadedEvent.isPresent());
+    }
 }