Launcher/LauncherAPI/src/main/java/pro/gravit/launcher/modules/LauncherModule.java

167 lines
4.7 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package pro.gravit.launcher.modules;
import java.util.HashMap;
import java.util.Map;
public abstract class LauncherModule {
private LauncherModulesContext context;
private Map<Class<? extends Event>, EventHandler> eventMap = new HashMap<>();
protected LauncherModulesManager modulesManager;
protected final LauncherModuleInfo moduleInfo;
protected ModulesConfigManager modulesConfigManager;
protected InitStatus initStatus = InitStatus.CREATED;
protected LauncherModule() {
moduleInfo = new LauncherModuleInfo("UnknownModule");
}
protected LauncherModule(LauncherModuleInfo info) {
moduleInfo = info;
}
public LauncherModuleInfo getModuleInfo() {
return moduleInfo;
}
/**
* Module initialization status at the current time
* CREATED - Module status immediately after loading
* INIT - The state of the module during the execution of the method init()
* FINISH - Status of the module after initialization
*/
public enum InitStatus
{
CREATED(false),
PRE_INIT_WAIT(true),
PRE_INIT(false),
INIT_WAIT(true),
INIT(false),
FINISH(true);
InitStatus(boolean b) {
isAvailable = b;
}
public boolean isAvailable() {
return isAvailable;
}
private final boolean isAvailable;
}
@FunctionalInterface
public interface EventHandler<T extends Event>
{
void event(T e);
}
public static class Event
{
public boolean isCancel() {
return cancel;
}
public Event cancel() {
this.cancel = true;
return this;
}
protected boolean cancel = false;
}
public InitStatus getInitStatus() {
return initStatus;
}
public LauncherModule setInitStatus(InitStatus initStatus) {
this.initStatus = initStatus;
return this;
}
/**
* The internal method used by the ModuleManager
* DO NOT TOUCH
* @param context Private context
*/
public void setContext(LauncherModulesContext context)
{
if(this.context != null) throw new IllegalStateException("Module already set context");
this.context = context;
this.modulesManager = context.getModulesManager();
this.modulesConfigManager = context.getModulesConfigManager();
this.setInitStatus(InitStatus.PRE_INIT_WAIT);
}
/**
* This method is called before initializing all modules and resolving dependencies.
* <b>You can</b>:
* Use to Module Manager
* Add custom modules not described in the manifest
* Change information about your module or modules you control
* <b>You can not</b>:
* Use your dependencies
* Use API Launcher, LaunchServer, ServerWrapper
* Change the names of any modules
*/
public void preInitAction() {
//NOP
}
public LauncherModule preInit()
{
if(!initStatus.equals(InitStatus.PRE_INIT_WAIT)) throw new IllegalStateException("PreInit not allowed in current state");
initStatus = InitStatus.PRE_INIT;
preInitAction();
initStatus = InitStatus.INIT_WAIT;
return this;
}
/**
* Basic module initialization method
* <b>You can</b>:
* Subscribe to events
* Use your dependencies
* Use provided initContext
* Receive modules and access the modules internal methods
* <b>You can not</b>:
* Modify module description, dependencies
* Add modules
* Read configuration
* @param initContext <s>null</s> on module initialization during boot or startup
* Not <s>null</s> during module initialization while running
*/
public abstract void init(LauncherInitContext initContext);
/**
* Registers an event handler for the current module
* @param handle your event handler
* @param tClass event class
* @param <T> event type
* @return true if adding a handler was successful
*/
protected <T extends Event> boolean registerEvent(EventHandler<T> handle, Class<T> tClass)
{
eventMap.put(tClass, handle);
return true;
}
/**
* Call the handler of the current module
* @param event event handled
* @param <T> event type
*/
@SuppressWarnings("unchecked")
public final <T extends Event> void callEvent(T event)
{
Class<? extends Event> tClass = event.getClass();
for(Map.Entry<Class<? extends Event>, EventHandler> e : eventMap.entrySet())
{
if(e.getKey().isAssignableFrom(tClass))
{
e.getValue().event(event);
if(event.isCancel()) return;
}
}
}
}