2024-08-07 10:22:01 +02:00
|
|
|
use jni::{objects::{JClass, JObject, JString, JValueGen}, sys::{jlong, jobject, jobjectArray, jstring}, JNIEnv};
|
2024-08-07 00:00:24 +02:00
|
|
|
use crate::Workspace;
|
2024-08-06 23:30:00 +02:00
|
|
|
|
2024-08-10 02:45:20 +02:00
|
|
|
use super::{JExceptable, RT};
|
2024-08-06 23:30:00 +02:00
|
|
|
|
2024-08-07 00:00:24 +02:00
|
|
|
/// Gets the workspace id.
|
|
|
|
#[no_mangle]
|
2024-08-07 00:37:58 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_get_1workspace_1id<'local>(
|
2024-08-10 02:45:20 +02:00
|
|
|
mut env: JNIEnv<'local>,
|
2024-08-07 00:00:24 +02:00
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong
|
|
|
|
) -> jstring {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
env.new_string(workspace.id()).jexcept(&mut env).as_raw()
|
2024-08-07 00:00:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets a cursor controller by name and returns a pointer to it.
|
|
|
|
#[no_mangle]
|
2024-08-07 00:37:58 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_get_1cursor<'local>(
|
2024-08-07 10:22:01 +02:00
|
|
|
mut env: JNIEnv<'local>,
|
2024-08-07 00:00:24 +02:00
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong
|
2024-08-07 10:22:01 +02:00
|
|
|
) -> jobject {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("mp/code/CursorController").and_then(|class|
|
|
|
|
env.new_object(class, "(J)V", &[JValueGen::Long(Box::into_raw(Box::new(workspace.cursor())) as jlong)])
|
|
|
|
).jexcept(&mut env).as_raw()
|
2024-08-07 00:00:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets a buffer controller by name and returns a pointer to it.
|
|
|
|
#[no_mangle]
|
2024-08-07 00:37:58 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_get_1buffer<'local>(
|
2024-08-07 10:22:01 +02:00
|
|
|
mut env: JNIEnv<'local>,
|
2024-08-07 00:00:24 +02:00
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>
|
2024-08-07 10:22:01 +02:00
|
|
|
) -> jobject {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let path = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
|
|
|
|
workspace.buffer_by_name(&path).map(|buf| {
|
|
|
|
env.find_class("mp/code/BufferController").and_then(|class|
|
|
|
|
env.new_object(class, "(J)V", &[JValueGen::Long(Box::into_raw(Box::new(buf)) as jlong)])
|
|
|
|
).jexcept(&mut env)
|
|
|
|
}).unwrap_or_default().as_raw()
|
2024-08-06 23:30:00 +02:00
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Creates a new buffer.
|
2024-08-06 23:30:00 +02:00
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_create_1buffer<'local>(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>
|
|
|
|
) {
|
2024-08-07 01:34:13 +02:00
|
|
|
let ws = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let path = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
RT.block_on(ws.create(&path))
|
|
|
|
.jexcept(&mut env);
|
2024-08-06 23:30:00 +02:00
|
|
|
}
|
2024-08-07 01:34:13 +02:00
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Gets the filetree.
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
2024-08-07 01:44:27 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_get_1file_1tree(
|
2024-08-07 02:43:25 +02:00
|
|
|
mut env: JNIEnv,
|
2024-08-07 01:44:27 +02:00
|
|
|
_class: JClass,
|
2024-08-07 01:34:13 +02:00
|
|
|
self_ptr: jlong,
|
2024-08-07 02:43:25 +02:00
|
|
|
) -> jobjectArray {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-07 02:43:25 +02:00
|
|
|
let file_tree = workspace.filetree();
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("java/lang/String")
|
|
|
|
.and_then(|class| env.new_object_array(file_tree.len() as i32, class, JObject::null()))
|
|
|
|
.map(|arr| {
|
|
|
|
for (idx, path) in file_tree.iter().enumerate() {
|
|
|
|
env.new_string(path)
|
|
|
|
.and_then(|path| env.set_object_array_element(&arr, idx as i32, path))
|
|
|
|
.jexcept(&mut env)
|
|
|
|
}
|
|
|
|
arr
|
|
|
|
}).jexcept(&mut env).as_raw()
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Attaches to a buffer and returns a pointer to its [crate::buffer::Controller].
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_attach_1to_1buffer<'local>(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass<'local>,
|
2024-08-07 01:44:27 +02:00
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>
|
2024-08-07 10:22:01 +02:00
|
|
|
) -> jobject {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let path = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
RT.block_on(workspace.attach(&path))
|
2024-08-07 01:44:27 +02:00
|
|
|
.map(|buffer| Box::into_raw(Box::new(buffer)) as jlong)
|
2024-08-07 10:22:01 +02:00
|
|
|
.map(|ptr| {
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("mp/code/BufferController")
|
|
|
|
.and_then(|class| env.new_object(class, "(J)V", &[JValueGen::Long(ptr)]))
|
|
|
|
.jexcept(&mut env)
|
2024-08-07 10:22:01 +02:00
|
|
|
}).jexcept(&mut env).as_raw()
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
|
|
|
|
2024-08-08 02:45:52 +02:00
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_detach_1from_1buffer<'local>(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>
|
|
|
|
) -> jobject {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let path = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
let name = match workspace.detach(&path) {
|
2024-08-09 14:11:13 +02:00
|
|
|
crate::workspace::worker::DetachResult::NotAttached => "NOT_ATTACHED",
|
|
|
|
crate::workspace::worker::DetachResult::Detaching => "DETACHED",
|
|
|
|
crate::workspace::worker::DetachResult::AlreadyDetached => "ALREADY_DETACHED"
|
2024-08-08 02:45:52 +02:00
|
|
|
};
|
|
|
|
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("mp/code/data/DetachResult")
|
|
|
|
.and_then(|class| env.get_static_field(class, name, "Lmp/code/data/DetachResult;"))
|
|
|
|
.and_then(|res| res.l())
|
|
|
|
.jexcept(&mut env)
|
2024-08-08 02:45:52 +02:00
|
|
|
.as_raw()
|
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Updates the local buffer list.
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
2024-08-07 01:44:27 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_fetch_1buffers(
|
2024-08-07 01:34:13 +02:00
|
|
|
mut env: JNIEnv,
|
2024-08-07 01:44:27 +02:00
|
|
|
_class: JClass,
|
2024-08-07 01:34:13 +02:00
|
|
|
self_ptr: jlong,
|
|
|
|
) {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-07 01:44:27 +02:00
|
|
|
RT.block_on(workspace.fetch_buffers()).jexcept(&mut env);
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Updates the local user list.
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
2024-08-07 01:44:27 +02:00
|
|
|
pub extern "system" fn Java_mp_code_Workspace_fetch_1users(
|
2024-08-07 01:34:13 +02:00
|
|
|
mut env: JNIEnv,
|
2024-08-07 01:44:27 +02:00
|
|
|
_class: JClass,
|
2024-08-07 01:34:13 +02:00
|
|
|
self_ptr: jlong,
|
|
|
|
) {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-07 01:44:27 +02:00
|
|
|
RT.block_on(workspace.fetch_users()).jexcept(&mut env);
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Lists users attached to a buffer.
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_list_1buffer_1users<'local>(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>,
|
2024-08-07 02:43:25 +02:00
|
|
|
) -> jobjectArray {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let buffer = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|buffer| buffer.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
let users = RT.block_on(workspace.list_buffer_users(&buffer))
|
2024-08-07 02:43:25 +02:00
|
|
|
.jexcept(&mut env);
|
|
|
|
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("java/lang/String")
|
|
|
|
.and_then(|class| env.new_object_array(users.len() as i32, class, JObject::null()))
|
|
|
|
.map(|arr| {
|
|
|
|
for (idx, user) in users.iter().enumerate() {
|
|
|
|
env.new_string(&user.id)
|
|
|
|
.and_then(|id| env.set_object_array_element(&arr, idx as i32, id))
|
|
|
|
.jexcept(&mut env);
|
|
|
|
}
|
|
|
|
arr
|
|
|
|
}).jexcept(&mut env).as_raw()
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
|
|
|
|
2024-08-07 01:44:27 +02:00
|
|
|
/// Deletes a buffer.
|
2024-08-07 01:34:13 +02:00
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_delete_1buffer<'local>(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass<'local>,
|
|
|
|
self_ptr: jlong,
|
|
|
|
input: JString<'local>,
|
|
|
|
) {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-10 02:45:20 +02:00
|
|
|
let buffer = unsafe { env.get_string_unchecked(&input) }
|
|
|
|
.map(|buffer| buffer.to_string_lossy().to_string())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
RT.block_on(workspace.delete(&buffer)).jexcept(&mut env);
|
2024-08-07 01:34:13 +02:00
|
|
|
}
|
2024-08-07 10:22:01 +02:00
|
|
|
|
2024-08-09 14:11:13 +02:00
|
|
|
/// Receives a workspace event if present.
|
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_event(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass,
|
|
|
|
self_ptr: jlong
|
|
|
|
) -> jobject {
|
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
|
|
|
RT.block_on(workspace.event())
|
|
|
|
.map(|event| {
|
|
|
|
let (name, arg) = match event {
|
|
|
|
crate::api::Event::FileTreeUpdated => ("FILE_TREE_UPDATED", None),
|
|
|
|
crate::api::Event::UserJoin(arg) => ("USER_JOIN", Some(arg)),
|
|
|
|
crate::api::Event::UserLeave(arg) => ("USER_LEAVE", Some(arg)),
|
|
|
|
};
|
2024-08-10 02:45:20 +02:00
|
|
|
let event_type = env.find_class("mp/code/Workspace$Event$Type")
|
|
|
|
.and_then(|class| env.get_static_field(class, name, "Lmp/code/Workspace/Event/Type;"))
|
|
|
|
.and_then(|f| f.l())
|
|
|
|
.jexcept(&mut env);
|
|
|
|
let arg = arg.map(|s| env.new_string(s).jexcept(&mut env))
|
2024-08-09 14:11:13 +02:00
|
|
|
.unwrap_or_default();
|
|
|
|
|
2024-08-10 02:45:20 +02:00
|
|
|
env.find_class("mp/code/Workspace$Event").and_then(|class|
|
|
|
|
env.new_object(
|
|
|
|
class,
|
|
|
|
"(Lmp/code/Workspace/Event/Type;Ljava/lang/String;)V",
|
|
|
|
&[
|
|
|
|
JValueGen::Object(&event_type),
|
|
|
|
JValueGen::Object(&arg)
|
|
|
|
]
|
|
|
|
)
|
|
|
|
).jexcept(&mut env)
|
2024-08-09 14:11:13 +02:00
|
|
|
}).jexcept(&mut env).as_raw()
|
|
|
|
}
|
|
|
|
|
2024-08-07 10:22:01 +02:00
|
|
|
/// Polls a list of buffers, returning the first ready one.
|
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_select_1buffer(
|
|
|
|
mut env: JNIEnv,
|
|
|
|
_class: JClass,
|
|
|
|
self_ptr: jlong,
|
|
|
|
timeout: jlong
|
|
|
|
) -> jobject {
|
2024-08-09 14:11:13 +02:00
|
|
|
let workspace = unsafe { Box::leak(Box::from_raw(self_ptr as *mut Workspace)) };
|
2024-08-07 10:22:01 +02:00
|
|
|
let buffers = workspace.buffer_list();
|
|
|
|
let mut controllers = Vec::default();
|
|
|
|
for buffer in buffers {
|
|
|
|
if let Some(controller) = workspace.buffer_by_name(&buffer) {
|
|
|
|
controllers.push(controller);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-08-13 21:58:40 +02:00
|
|
|
RT.block_on(crate::ext::select_buffer(
|
2024-08-07 10:22:01 +02:00
|
|
|
&controllers,
|
|
|
|
Some(std::time::Duration::from_millis(timeout as u64)),
|
|
|
|
&RT,
|
2024-08-10 02:45:20 +02:00
|
|
|
)).jexcept(&mut env)
|
|
|
|
.map(|buf| {
|
|
|
|
env.find_class("mp/code/BufferController").and_then(|class|
|
|
|
|
env.new_object(class, "(J)V", &[JValueGen::Long(Box::into_raw(Box::new(buf)) as jlong)])
|
|
|
|
).jexcept(&mut env)
|
|
|
|
}).unwrap_or_default().as_raw()
|
2024-08-07 10:22:01 +02:00
|
|
|
}
|
2024-08-08 00:29:54 +02:00
|
|
|
|
|
|
|
/// Called by the Java GC to drop a [Workspace].
|
|
|
|
#[no_mangle]
|
|
|
|
pub extern "system" fn Java_mp_code_Workspace_free(_env: JNIEnv, _class: JClass, input: jlong) {
|
|
|
|
let _ = unsafe { Box::from_raw(input as *mut Workspace) };
|
|
|
|
}
|