Set plugin instances

java/patchbukkit/src/main/java/org/patchbukkit/CallbackValue.java

@@ -10,7 +10,7 @@ public class CallbackValue {
         this.args = args;
     }
 
-    public Object getArg(int arg) {
+    public Object getArg(Integer arg) {
         return args[arg];
     }
 

rust/src/events/join.rs

@@ -7,16 +7,21 @@ use pumpkin::{
 use pumpkin_api_macros::with_runtime;
 use pumpkin_util::text::{TextComponent, color::NamedColor};
 
-pub struct PatchBukkitJoinHandler;
+use crate::plugin::manager::Plugins;
+
+pub struct PatchBukkitJoinHandler {
+    pub plugins: Plugins,
+}
 
 #[with_runtime(global)]
 impl EventHandler<PlayerJoinEvent> for PatchBukkitJoinHandler {
     fn handle_blocking<'a>(
         &self,
-        _server: &Arc<Server>,
+        server: &Arc<Server>,
         event: &'a mut PlayerJoinEvent,
     ) -> BoxFuture<'a, ()> {
         Box::pin(async {
+            for (_plugin_name, plugin) in self.plugins.lock().unwrap().iter_mut() {}
             event.join_message =
                 TextComponent::text(format!("Welcome, {}!", event.player.gameprofile.name))
                     .color_named(NamedColor::Green);

rust/src/events/mod.rs

@@ -2,14 +2,14 @@ use std::sync::Arc;
 
 use pumpkin::plugin::{Context, EventPriority};
 
-use crate::events::join::PatchBukkitJoinHandler;
+use crate::{events::join::PatchBukkitJoinHandler, plugin::manager::Plugins};
 
 pub mod join;
 
-pub async fn register_handlers(server: &Arc<Context>) {
+pub async fn register_handlers(plugins: Plugins, server: &Arc<Context>) {
     server
         .register_event(
-            Arc::new(PatchBukkitJoinHandler),
+            Arc::new(PatchBukkitJoinHandler { plugins }),
             EventPriority::Highest,
             true,
         )

rust/src/lib.rs

@@ -80,6 +80,7 @@ async fn on_load_inner(plugin: &mut PatchBukkitPlugin, server: Arc<Context>) ->
         .map_err(|err| err.to_string())?;
     let r = jvm.init_callback_channel(&i).unwrap();
 
+    let plugins = plugin.plugin_manager.plugins.clone();
     std::thread::spawn(move || {
         let jvm = match Jvm::attach_thread() {
             Ok(jvm) => jvm,
@@ -92,22 +93,53 @@ async fn on_load_inner(plugin: &mut PatchBukkitPlugin, server: Arc<Context>) ->
         loop {
             match r.rx().recv() {
                 Ok(ret) => {
-                    let _: anyhow::Result<()> = (|| {
+                    let result: anyhow::Result<()> = (|| {
                         let result = jvm.invoke(&ret, "getCallbackName", InvocationArg::empty())?;
 
                         let callback_name: String = jvm.to_rust(result)?;
                         match callback_name.as_str() {
                             "REGISTER_EVENT_CALLBACK" => {
-                                let listener =
+                                let listener_name: String = jvm.to_rust(jvm.invoke(
-                                    jvm.invoke(&ret, "getArg", &[&InvocationArg::try_from(0)?])?;
+                                    &ret,
-                                let plugin =
+                                    "getArg",
-                                    jvm.invoke(&ret, "getArg", &[&InvocationArg::try_from(1)?])?;
+                                    &[&InvocationArg::try_from(0_i32)?],
+                                )?)?;
+                                let listener = jvm.cast(
+                                    &jvm.invoke(
+                                        &ret,
+                                        "getArg",
+                                        &[&InvocationArg::try_from(1_i32)?],
+                                    )?,
+                                    "org.bukkit.event.Listener",
+                                )?;
+                                let plugin_instance = jvm.cast(
+                                    &jvm.invoke(
+                                        &ret,
+                                        "getArg",
+                                        &[&InvocationArg::try_from(2_i32)?],
+                                    )?,
+                                    "org.bukkit.plugin.Plugin",
+                                )?;
+                                let plugin_name: String = jvm.to_rust(jvm.invoke(
+                                    &plugin_instance,
+                                    "getName",
+                                    InvocationArg::empty(),
+                                )?)?;
+
+                                match plugins.lock().unwrap().get_mut(&plugin_name) {
+                                    Some(rust_plugin) => {
+                                        rust_plugin.listeners.insert(listener_name, listener)
+                                    }
+                                    None => todo!(),
+                                };
                             }
                             _ => log::warn!("Received unknown callback: {:?}", callback_name),
                         }
 
                         return Ok(());
                     })();
+
+                    result.unwrap();
                 }
                 Err(e) => {
                     log::error!("Callback channel closed: {}", e);

rust/src/plugin/manager.rs

@@ -56,10 +56,12 @@ pub struct Plugin {
     /// Data folder for this plugin
     pub data_folder: PathBuf,
     pub instance: Option<Instance>,
+    pub listeners: HashMap<String, Instance>,
 }
 
+pub type Plugins = Arc<Mutex<HashMap<String, Plugin>>>;
 pub struct PluginManager {
-    plugins: Arc<Mutex<HashMap<String, Plugin>>>,
+    pub plugins: Plugins,
 }
 
 impl PluginManager {
@@ -100,6 +102,7 @@ impl PluginManager {
             data_folder: jar_path.as_ref().parent().unwrap().join("data"),
             path: jar_path.as_ref().to_path_buf(),
             instance: None,
+            listeners: HashMap::new(),
         };
 
         self.add_plugin(plugin);
@@ -124,6 +127,7 @@ impl PluginManager {
             data_folder: jar_path.as_ref().parent().unwrap().join("data"),
             path: jar_path.as_ref().to_path_buf(),
             instance: None,
+            listeners: HashMap::new(),
         };
 
         self.add_plugin(plugin);