chore(java): use prelude imports

Author: zaaarf

src/ffi/java/buffer.rs

@@ -1,10 +1,12 @@
-use jni::{Env, objects::JObject};
 use jni_toolbox::jni;
 
 use crate::{
-	api::{AsyncReceiver, AsyncSender, BufferUpdate, TextChange},
 	errors::ControllerError,
-	proto::session::WorkspaceIdentifier
+	prelude::{
+		CodempAsyncReceiver as AsyncReceiver, CodempAsyncSender as AsyncSender,
+		CodempBufferUpdate as BufferUpdate, CodempTextChange as TextChange,
+		CodempWorkspaceIdentifier as WorkspaceIdentifier,
+	},
 };
 
 /// Get the name of the buffer.
@@ -51,16 +53,18 @@ fn send(
 /// Register a callback for buffer changes.
 #[jni(package = "mp.code", class = "BufferController")]
 fn callback<'local>(
-	env: &mut Env<'local>,
+	env: &mut jni::Env<'local>,
 	controller: &mut crate::buffer::Controller,
-	cb: JObject<'local>,
+	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
-		return Err(jni::errors::Error::NullPtr("null pointer to buffer callback"));
+		return Err(jni::errors::Error::NullPtr(
+			"null pointer to buffer callback",
+		));
 	}
 
 	let cb_ref = env.new_global_ref(cb)?;
-	let jvm =	env.get_java_vm()?;
+	let jvm = env.get_java_vm()?;
 
 	controller.callback(move |controller: crate::buffer::Controller| {
 		let result: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {

src/ffi/java/client.rs

@@ -1,11 +1,13 @@
+use jni_toolbox::jni;
+
 use crate::{
-	Workspace,
-	api::{AsyncReceiver, Config},
-	client::Client,
 	errors::{ConnectionError, ControllerError, RemoteError},
-	proto::{common::UserInfo, session::{SessionEvent, WorkspaceIdentifier}}
+	prelude::{
+		CodempAsyncReceiver as AsyncReceiver, CodempClient as Client, CodempConfig as Config,
+		CodempSessionEvent as SessionEvent, CodempUserInfo as UserInfo,
+		CodempWorkspace as Workspace, CodempWorkspaceIdentifier as WorkspaceIdentifier,
+	},
 };
-use jni_toolbox::jni;
 
 /// Connect using the given credentials to the default server, and return a [Client] to interact with it.
 #[jni(package = "mp.code", class = "Client")]
@@ -21,7 +23,11 @@ fn current_user(client: &mut Client) -> UserInfo {
 
 /// Join a [Workspace] and return a pointer to it.
 #[jni(package = "mp.code", class = "Client")]
-fn attach_workspace(client: &mut Client, user: String, workspace: String) -> Result<Workspace, ConnectionError> {
+fn attach_workspace(
+	client: &mut Client,
+	user: String,
+	workspace: String,
+) -> Result<Workspace, ConnectionError> {
 	super::tokio().block_on(client.attach_workspace(user, workspace))
 }
 
@@ -57,7 +63,11 @@ fn delete_workspace(client: &mut Client, workspace: String) -> Result<(), Remote
 
 /// Invite another user to an owned workspace.
 #[jni(package = "mp.code", class = "Client")]
-fn invite_to_workspace(client: &mut Client, workspace: String, user: String) -> Result<(), RemoteError> {
+fn invite_to_workspace(
+	client: &mut Client,
+	workspace: String,
+	user: String,
+) -> Result<(), RemoteError> {
 	super::tokio().block_on(client.invite_to_workspace(workspace, user))
 }
 
@@ -117,11 +127,13 @@ fn callback<'local>(
 	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
-		return Err(jni::errors::Error::NullPtr("null pointer to buffer callback"));
+		return Err(jni::errors::Error::NullPtr(
+			"null pointer to buffer callback",
+		));
 	}
 
 	let cb_ref = env.new_global_ref(cb)?;
-	let jvm =	env.get_java_vm()?;
+	let jvm = env.get_java_vm()?;
 
 	client.callback(move |controller: Client| {
 		let result: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {

src/ffi/java/cursor.rs

@@ -1,10 +1,13 @@
+use jni_toolbox::jni;
+
 use crate::{
-	api::{AsyncReceiver, AsyncSender},
 	errors::ControllerError,
-	proto::{cursor::{CursorEvent, CursorUpdate}, session::WorkspaceIdentifier}
+	prelude::{
+		CodempAsyncReceiver as AsyncReceiver, CodempAsyncSender as AsyncSender,
+		CodempCursorEvent as CursorEvent, CodempCursorUpdate as CursorUpdate,
+		CodempWorkspaceIdentifier as WorkspaceIdentifier,
+	},
 };
-use jni::{Env, objects::JObject};
-use jni_toolbox::jni;
 
 /// Get the [WorkspaceIdentifier] of the workspace that contains this buffer.
 #[jni(package = "mp.code", class = "CursorController")]
@@ -14,7 +17,9 @@ fn workspace_id(controller: &mut crate::cursor::Controller) -> WorkspaceIdentifi
 
 /// Try to fetch a [Cursor], or returns null if there's nothing.
 #[jni(package = "mp.code", class = "CursorController")]
-fn try_recv(controller: &mut crate::cursor::Controller) -> Result<Option<CursorEvent>, ControllerError> {
+fn try_recv(
+	controller: &mut crate::cursor::Controller,
+) -> Result<Option<CursorEvent>, ControllerError> {
 	super::tokio().block_on(controller.try_recv())
 }
 
@@ -26,23 +31,26 @@ fn recv(controller: &mut crate::cursor::Controller) -> Result<CursorEvent, Contr
 
 /// Receive from Java, converts and sends a [Cursor].
 #[jni(package = "mp.code", class = "CursorController")]
-fn send(controller: &mut crate::cursor::Controller, sel: CursorUpdate) -> Result<(), ControllerError> {
+fn send(
+	controller: &mut crate::cursor::Controller,
+	sel: CursorUpdate,
+) -> Result<(), ControllerError> {
 	controller.send(sel)
 }
 
 /// Register a callback for cursor changes.
 #[jni(package = "mp.code", class = "CursorController")]
 fn callback<'local>(
-	env: &mut Env<'local>,
+	env: &mut jni::Env<'local>,
 	controller: &mut crate::cursor::Controller,
-	cb: JObject<'local>,
+	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
 		return Err(jni::errors::Error::NullPtr("cursor callback is null"));
 	}
 
 	let cb_ref = env.new_global_ref(cb)?;
-	let jvm =	env.get_java_vm()?;
+	let jvm = env.get_java_vm()?;
 
 	controller.callback(move |controller: crate::cursor::Controller| {
 		let res: Result<(), jni::errors::Error> = jvm.attach_current_thread(|env| {

src/ffi/java/mod.rs

@@ -90,9 +90,10 @@ impl jni_toolbox::IntoException for crate::errors::ControllerError {
 	}
 }
 
-
-macro_rules! from_java_ptr {
-	($type: ty) => {
+/// Generates a [jni_toolbox::IntoJava] and [jni_toolbox::FromJava] implementations
+/// for a class that is just a holder for a pointer.
+macro_rules! java_ptr_class {
+	($type: ty, $jclass: literal) => {
 		impl<'j> jni_toolbox::FromJava<'j> for &mut $type {
 			type From = jni::sys::jobject;
 			#[allow(unsafe_code)]
@@ -110,17 +111,7 @@ macro_rules! from_java_ptr {
 				Self::from_java(env, value.l()?.into_raw())
 			}
 		}
-	};
-}
-
-from_java_ptr!(crate::Client);
-from_java_ptr!(crate::Workspace);
-from_java_ptr!(crate::cursor::Controller);
-from_java_ptr!(crate::buffer::Controller);
 
-/// Generates a [JObjectify] implementation for a class that is just a holder for a pointer.
-macro_rules! into_java_ptr_class {
-	($type: ty, $jclass: literal) => {
 		impl<'j> jni_toolbox::IntoJavaObject<'j> for $type {
 			const CLASS: &'static str = $jclass;
 			fn into_java_object(
@@ -140,7 +131,13 @@ macro_rules! into_java_ptr_class {
 	};
 }
 
-into_java_ptr_class!(crate::Client, "mp/code/Client");
-into_java_ptr_class!(crate::Workspace, "mp/code/Workspace");
-into_java_ptr_class!(crate::cursor::Controller, "mp/code/CursorController");
-into_java_ptr_class!(crate::buffer::Controller, "mp/code/BufferController");
+java_ptr_class!(crate::prelude::CodempClient, "mp/code/Client");
+java_ptr_class!(crate::prelude::CodempWorkspace, "mp/code/Workspace");
+java_ptr_class!(
+	crate::prelude::CodempBufferController,
+	"mp/code/BufferController"
+);
+java_ptr_class!(
+	crate::prelude::CodempCursorController,
+	"mp/code/CursorController"
+);

src/ffi/java/workspace.rs

@@ -1,12 +1,13 @@
+use jni_toolbox::jni;
+
 use crate::{
-	Workspace,
-	api::controller::AsyncReceiver,
 	errors::{ConnectionError, ControllerError, RemoteError},
-	proto::{common::UserInfo, session::WorkspaceIdentifier, workspace::WorkspaceEvent}
+	prelude::{
+		CodempAsyncReceiver as AsyncReceiver, CodempBufferAttributes as BufferAttributes,
+		CodempBufferNode as BufferNode, CodempUserInfo as UserInfo, CodempWorkspace as Workspace,
+		CodempWorkspaceEvent as WorkspaceEvent, CodempWorkspaceIdentifier as WorkspaceIdentifier,
+	},
 };
-use codemp_proto::files::{BufferAttributes, BufferNode};
-use jni::{Env, objects::JObject};
-use jni_toolbox::jni;
 
 /// Get the workspace id.
 #[jni(package = "mp.code", class = "Workspace")]
@@ -46,7 +47,11 @@ fn user_list(workspace: &mut Workspace) -> Vec<UserInfo> {
 
 /// Create a new buffer.
 #[jni(package = "mp.code", class = "Workspace")]
-fn create_buffer(workspace: &mut Workspace, path: String, attributes: Option<BufferAttributes>) -> Result<(), RemoteError> {
+fn create_buffer(
+	workspace: &mut Workspace,
+	path: String,
+	attributes: Option<BufferAttributes>,
+) -> Result<(), RemoteError> {
 	super::tokio().block_on(workspace.create_buffer(path, attributes))
 }
 
@@ -64,7 +69,10 @@ fn un_pin_buffer(workspace: &mut Workspace, path: String) -> Result<(), RemoteEr
 
 /// Attach to a buffer and return a pointer to its [`crate::buffer::Controller`].
 #[jni(package = "mp.code", class = "Workspace")]
-fn attach_buffer(workspace: &mut Workspace, path: String) -> Result<crate::buffer::Controller, ConnectionError> {
+fn attach_buffer(
+	workspace: &mut Workspace,
+	path: String,
+) -> Result<crate::buffer::Controller, ConnectionError> {
 	super::tokio().block_on(workspace.attach_buffer(&path))
 }
 
@@ -131,12 +139,14 @@ fn clear_callback(workspace: &mut Workspace) {
 /// Register a callback for workspace events.
 #[jni(package = "mp.code", class = "Workspace")]
 fn callback<'local>(
-	env: &mut Env<'local>,
+	env: &mut jni::Env<'local>,
 	controller: &mut crate::Workspace,
-	cb: JObject<'local>,
+	cb: jni::objects::JObject<'local>,
 ) -> Result<(), jni::errors::Error> {
 	if cb.is_null() {
-		return Err(jni::errors::Error::NullPtr("null pointer to workspace callback"));
+		return Err(jni::errors::Error::NullPtr(
+			"null pointer to workspace callback",
+		));
 	}
 
 	let cb_ref = env.new_global_ref(cb)?;