Return `AutoLocal` from `IntoJava` implementations

4 files changed, 237 insertions, 190 deletions

diff --git a/mullvad-jni/src/into_java.rs b/mullvad-jni/src/into_java.rs
index e9cefeeafc..42cec028d9 100644
--- a/mullvad-jni/src/into_java.rs
+++ b/mullvad-jni/src/into_java.rs
@@ -2,7 +2,7 @@ use crate::daemon_interface;
 use ipnetwork::IpNetwork;
 use jnix::{
     jni::{
-        objects::{JList, JObject, JString, JValue},
+        objects::{AutoLocal, JList, JObject, JValue},
         signature::JavaType,
         sys::{jboolean, jint, jshort, jsize},
     },
@@ -38,15 +38,14 @@ pub trait IntoJava<'borrow, 'env: 'borrow> {
 impl<'borrow, 'env, T> IntoJava<'borrow, 'env> for Option<T>
 where
     'env: 'borrow,
-    T: IntoJava<'borrow, 'env>,
-    T::JavaType: From<JObject<'env>>,
+    T: IntoJava<'borrow, 'env, JavaType = AutoLocal<'env, 'borrow>>,
 {
-    type JavaType = T::JavaType;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         match self {
             Some(data) => data.into_java(env),
-            None => T::JavaType::from(JObject::null()),
+            None => env.auto_local(JObject::null()),
         }
     }
 }
@@ -55,20 +54,19 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for String
 where
     'env: 'borrow,
 {
-    type JavaType = JString<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        env.new_string(&self).expect("Failed to create Java String")
+        env.auto_local(*env.new_string(&self).expect("Failed to create Java String"))
     }
 }
 
 impl<'borrow, 'env, T> IntoJava<'borrow, 'env> for Vec<T>
 where
     'env: 'borrow,
-    T: IntoJava<'borrow, 'env>,
-    JObject<'env>: From<T::JavaType>,
+    T: IntoJava<'borrow, 'env, JavaType = AutoLocal<'env, 'borrow>>,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("java/util/ArrayList");
@@ -83,13 +81,13 @@ where
             JList::from_env(env, list_object).expect("Failed to create JList from ArrayList");
 
         for element in self {
-            let java_element = env.auto_local(JObject::from(element.into_java(env)));
+            let java_element = element.into_java(env);
 
             list.add(java_element.as_obj())
                 .expect("Failed to add element to ArrayList");
         }
 
-        list_object
+        env.auto_local(list_object)
     }
 }
 
@@ -97,7 +95,7 @@ impl<'array, 'borrow, 'env> IntoJava<'borrow, 'env> for &'array [u8]
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let size = self.len();
@@ -110,11 +108,17 @@ where
         env.set_byte_array_region(array, 0, data)
             .expect("Failed to copy bytes to Java array");
 
-        JObject::from(array)
+        env.auto_local(JObject::from(array))
     }
 }
 
-fn ipvx_addr_into_java<'env>(original_octets: &[u8], env: &JnixEnv<'env>) -> JObject<'env> {
+fn ipvx_addr_into_java<'env, 'borrow>(
+    original_octets: &[u8],
+    env: &'borrow JnixEnv<'env>,
+) -> AutoLocal<'env, 'borrow>
+where
+    'env: 'borrow,
+{
     let class = env.get_class("java/net/InetAddress");
 
     let constructor = env
@@ -144,7 +148,7 @@ fn ipvx_addr_into_java<'env>(original_octets: &[u8], env: &JnixEnv<'env>) -> JOb
         .expect("Failed to create InetAddress Java object");
 
     match result {
-        JValue::Object(object) => JObject::from(object.into_inner()),
+        JValue::Object(object) => env.auto_local(JObject::from(object.into_inner())),
         value => {
             panic!(
                 "InetAddress.getByAddress returned an invalid value: {:?}",
@@ -158,7 +162,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Ipv4Addr
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         ipvx_addr_into_java(self.octets().as_ref(), env)
@@ -169,7 +173,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Ipv6Addr
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         ipvx_addr_into_java(self.octets().as_ref(), env)
@@ -180,7 +184,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for IpAddr
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         match self {
@@ -194,16 +198,18 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for SocketAddr
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("java/net/InetSocketAddress");
-        let ip_address = env.auto_local(self.ip().into_java(env));
+        let ip_address = self.ip().into_java(env);
         let port = self.port() as jint;
         let parameters = [JValue::Object(ip_address.as_obj()), JValue::Int(port)];
 
-        env.new_object(&class, "(Ljava/net/InetAddress;I)V", &parameters)
-            .expect("Failed to create InetSocketAddress Java object")
+        env.auto_local(
+            env.new_object(&class, "(Ljava/net/InetAddress;I)V", &parameters)
+                .expect("Failed to create InetSocketAddress Java object"),
+        )
     }
 }
 
@@ -211,19 +217,21 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for IpNetwork
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/talpid/tun_provider/InetNetwork");
-        let address = env.auto_local(self.ip().into_java(env));
+        let address = self.ip().into_java(env);
         let prefix_length = self.prefix() as jshort;
         let parameters = [
             JValue::Object(address.as_obj()),
             JValue::Short(prefix_length),
         ];
 
-        env.new_object(&class, "(Ljava/net/InetAddress;S)V", &parameters)
-            .expect("Failed to create InetNetwork Java object")
+        env.auto_local(
+            env.new_object(&class, "(Ljava/net/InetAddress;S)V", &parameters)
+                .expect("Failed to create InetNetwork Java object"),
+        )
     }
 }
 
@@ -231,19 +239,21 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for PublicKey
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/PublicKey");
-        let key = env.auto_local(self.key.as_bytes().into_java(env));
-        let date_created = env.auto_local(*self.created.to_string().into_java(env));
+        let key = self.key.as_bytes().into_java(env);
+        let date_created = self.created.to_string().into_java(env);
         let parameters = [
             JValue::Object(key.as_obj()),
             JValue::Object(date_created.as_obj()),
         ];
 
-        env.new_object(&class, "([BLjava/lang/String;)V", &parameters)
-            .expect("Failed to create PublicKey Java object")
+        env.auto_local(
+            env.new_object(&class, "([BLjava/lang/String;)V", &parameters)
+                .expect("Failed to create PublicKey Java object"),
+        )
     }
 }
 
@@ -251,14 +261,14 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for AppVersionInfo
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/AppVersionInfo");
         let current_is_supported = self.current_is_supported as jboolean;
         let current_is_outdated = self.current_is_outdated as jboolean;
-        let latest_stable = env.auto_local(*self.latest_stable.into_java(env));
-        let latest = env.auto_local(*self.latest.into_java(env));
+        let latest_stable = self.latest_stable.into_java(env);
+        let latest = self.latest.into_java(env);
         let parameters = [
             JValue::Bool(current_is_supported),
             JValue::Bool(current_is_outdated),
@@ -266,12 +276,14 @@ where
             JValue::Object(latest.as_obj()),
         ];
 
-        env.new_object(
-            &class,
-            "(ZZLjava/lang/String;Ljava/lang/String;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(ZZLjava/lang/String;Ljava/lang/String;)V",
+                &parameters,
+            )
+            .expect("Failed to create AppVersionInfo Java object"),
         )
-        .expect("Failed to create AppVersionInfo Java object")
     }
 }
 
@@ -279,15 +291,17 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for AccountData
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/AccountData");
-        let account_expiry = env.auto_local(JObject::from(self.expiry.to_string().into_java(env)));
+        let account_expiry = self.expiry.to_string().into_java(env);
         let parameters = [JValue::Object(account_expiry.as_obj())];
 
-        env.new_object(&class, "(Ljava/lang/String;)V", &parameters)
-            .expect("Failed to create AccountData Java object")
+        env.auto_local(
+            env.new_object(&class, "(Ljava/lang/String;)V", &parameters)
+                .expect("Failed to create AccountData Java object"),
+        )
     }
 }
 
@@ -295,13 +309,13 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for TunConfig
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/talpid/tun_provider/TunConfig");
-        let addresses = env.auto_local(self.addresses.into_java(env));
-        let dns_servers = env.auto_local(self.dns_servers.into_java(env));
-        let routes = env.auto_local(self.routes.into_java(env));
+        let addresses = self.addresses.into_java(env);
+        let dns_servers = self.dns_servers.into_java(env);
+        let routes = self.routes.into_java(env);
         let mtu = self.mtu as jint;
         let parameters = [
             JValue::Object(addresses.as_obj()),
@@ -310,12 +324,14 @@ where
             JValue::Int(mtu),
         ];
 
-        env.new_object(
-            &class,
-            "(Ljava/util/List;Ljava/util/List;Ljava/util/List;I)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Ljava/util/List;Ljava/util/List;Ljava/util/List;I)V",
+                &parameters,
+            )
+            .expect("Failed to create TunConfig Java object"),
         )
-        .expect("Failed to create TunConfig Java object")
     }
 }
 
@@ -323,7 +339,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for TransportProtocol
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class_name = match self {
@@ -332,8 +348,10 @@ where
         };
         let class = env.get_class(class_name);
 
-        env.new_object(&class, "()V", &[])
-            .expect("Failed to create TransportProtocol sub-class variant Java object")
+        env.auto_local(
+            env.new_object(&class, "()V", &[])
+                .expect("Failed to create TransportProtocol sub-class variant Java object"),
+        )
     }
 }
 
@@ -341,23 +359,25 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Endpoint
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/talpid/net/Endpoint");
-        let address = env.auto_local(self.address.into_java(env));
-        let protocol = env.auto_local(self.protocol.into_java(env));
+        let address = self.address.into_java(env);
+        let protocol = self.protocol.into_java(env);
         let parameters = [
             JValue::Object(address.as_obj()),
             JValue::Object(protocol.as_obj()),
         ];
 
-        env.new_object(
-            &class,
-            "(Ljava/net/InetSocketAddress;Lnet/mullvad/talpid/net/TransportProtocol;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Ljava/net/InetSocketAddress;Lnet/mullvad/talpid/net/TransportProtocol;)V",
+                &parameters,
+            )
+            .expect("Failed to create Endpoint sub-class variant Java object"),
         )
-        .expect("Failed to create Endpoint sub-class variant Java object")
     }
 }
 
@@ -365,15 +385,21 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for TunnelEndpoint
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/talpid/net/TunnelEndpoint");
-        let endpoint = env.auto_local(self.endpoint.into_java(env));
+        let endpoint = self.endpoint.into_java(env);
         let parameters = [JValue::Object(endpoint.as_obj())];
 
-        env.new_object(&class, "(Lnet/mullvad/talpid/net/Endpoint;)V", &parameters)
-            .expect("Failed to create TunnelEndpoint sub-class variant Java object")
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Lnet/mullvad/mullvadvpn/model/Endpoint;)V",
+                &parameters,
+            )
+            .expect("Failed to create TunnelEndpoint sub-class variant Java object"),
+        )
     }
 }
 
@@ -381,15 +407,15 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for GeoIpLocation
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/GeoIpLocation");
-        let ipv4 = env.auto_local(self.ipv4.into_java(env));
-        let ipv6 = env.auto_local(self.ipv6.into_java(env));
-        let country = env.auto_local(JObject::from(self.country.into_java(env)));
-        let city = env.auto_local(JObject::from(self.city.into_java(env)));
-        let hostname = env.auto_local(JObject::from(self.hostname.into_java(env)));
+        let ipv4 = self.ipv4.into_java(env);
+        let ipv6 = self.ipv6.into_java(env);
+        let country = self.country.into_java(env);
+        let city = self.city.into_java(env);
+        let hostname = self.hostname.into_java(env);
         let parameters = [
             JValue::Object(ipv4.as_obj()),
             JValue::Object(ipv6.as_obj()),
@@ -398,12 +424,12 @@ where
             JValue::Object(hostname.as_obj()),
         ];
 
-        env.new_object(
+        env.auto_local(env.new_object(
             &class,
             "(Ljava/net/InetAddress;Ljava/net/InetAddress;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
             &parameters,
         )
-        .expect("Failed to create GeoIpLocation Java object")
+        .expect("Failed to create GeoIpLocation Java object"))
     }
 }
 
@@ -411,15 +437,17 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for RelayList
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/RelayList");
-        let relay_countries = env.auto_local(self.countries.into_java(env));
+        let relay_countries = self.countries.into_java(env);
         let parameters = [JValue::Object(relay_countries.as_obj())];
 
-        env.new_object(&class, "(Ljava/util/List;)V", &parameters)
-            .expect("Failed to create RelayList Java object")
+        env.auto_local(
+            env.new_object(&class, "(Ljava/util/List;)V", &parameters)
+                .expect("Failed to create RelayList Java object"),
+        )
     }
 }
 
@@ -427,25 +455,27 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for RelayListCountry
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/RelayListCountry");
-        let name = env.auto_local(JObject::from(self.name.into_java(env)));
-        let code = env.auto_local(JObject::from(self.code.into_java(env)));
-        let relay_cities = env.auto_local(self.cities.into_java(env));
+        let name = self.name.into_java(env);
+        let code = self.code.into_java(env);
+        let relay_cities = self.cities.into_java(env);
         let parameters = [
             JValue::Object(name.as_obj()),
             JValue::Object(code.as_obj()),
             JValue::Object(relay_cities.as_obj()),
         ];
 
-        env.new_object(
-            &class,
-            "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V",
+                &parameters,
+            )
+            .expect("Failed to create RelayListCountry Java object"),
         )
-        .expect("Failed to create RelayListCountry Java object")
     }
 }
 
@@ -453,25 +483,27 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for RelayListCity
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/RelayListCity");
-        let name = env.auto_local(JObject::from(self.name.into_java(env)));
-        let code = env.auto_local(JObject::from(self.code.into_java(env)));
-        let relays = env.auto_local(self.relays.into_java(env));
+        let name = self.name.into_java(env);
+        let code = self.code.into_java(env);
+        let relays = self.relays.into_java(env);
         let parameters = [
             JValue::Object(name.as_obj()),
             JValue::Object(code.as_obj()),
             JValue::Object(relays.as_obj()),
         ];
 
-        env.new_object(
-            &class,
-            "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V",
+                &parameters,
+            )
+            .expect("Failed to create RelayListCity Java object"),
         )
-        .expect("Failed to create RelayListCity Java object")
     }
 }
 
@@ -479,11 +511,11 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Relay
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/Relay");
-        let hostname = env.auto_local(JObject::from(self.hostname.into_java(env)));
+        let hostname = self.hostname.into_java(env);
         let has_wireguard_tunnels = (!self.tunnels.wireguard.is_empty()) as jboolean;
         let parameters = [
             JValue::Object(hostname.as_obj()),
@@ -491,21 +523,22 @@ where
             JValue::Bool(self.active as jboolean),
         ];
 
-        env.new_object(&class, "(Ljava/lang/String;ZZ)V", &parameters)
-            .expect("Failed to create Relay Java object")
+        env.auto_local(
+            env.new_object(&class, "(Ljava/lang/String;ZZ)V", &parameters)
+                .expect("Failed to create Relay Java object"),
+        )
     }
 }
 
 impl<'borrow, 'env, T> IntoJava<'borrow, 'env> for Constraint<T>
 where
     'env: 'borrow,
-    T: Clone + Eq + Debug + IntoJava<'borrow, 'env>,
-    JObject<'env>: From<T::JavaType>,
+    T: Clone + Eq + Debug + IntoJava<'borrow, 'env, JavaType = AutoLocal<'env, 'borrow>>,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        match self {
+        env.auto_local(match self {
             Constraint::Any => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/Constraint$Any");
 
@@ -514,13 +547,13 @@ where
             }
             Constraint::Only(constraint) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/Constraint$Only");
-                let value = env.auto_local(JObject::from(constraint.into_java(env)));
+                let value = constraint.into_java(env);
                 let parameters = [JValue::Object(value.as_obj())];
 
                 env.new_object(&class, "(Ljava/lang/Object;)V", &parameters)
                     .expect("Failed to create Constraint.Only Java object")
             }
-        }
+        })
     }
 }
 
@@ -528,14 +561,14 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for LocationConstraint
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        match self {
+        env.auto_local(match self {
             LocationConstraint::Country(country_code) => {
                 let class =
                     env.get_class("net/mullvad/mullvadvpn/model/LocationConstraint$Country");
-                let country = env.auto_local(JObject::from(country_code.into_java(env)));
+                let country = country_code.into_java(env);
                 let parameters = [JValue::Object(country.as_obj())];
 
                 env.new_object(&class, "(Ljava/lang/String;)V", &parameters)
@@ -543,8 +576,8 @@ where
             }
             LocationConstraint::City(country_code, city_code) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/LocationConstraint$City");
-                let country = env.auto_local(JObject::from(country_code.into_java(env)));
-                let city = env.auto_local(JObject::from(city_code.into_java(env)));
+                let country = country_code.into_java(env);
+                let city = city_code.into_java(env);
                 let parameters = [
                     JValue::Object(country.as_obj()),
                     JValue::Object(city.as_obj()),
@@ -560,9 +593,9 @@ where
             LocationConstraint::Hostname(country_code, city_code, hostname) => {
                 let class =
                     env.get_class("net/mullvad/mullvadvpn/model/LocationConstraint$Hostname");
-                let country = env.auto_local(JObject::from(country_code.into_java(env)));
-                let city = env.auto_local(JObject::from(city_code.into_java(env)));
-                let hostname = env.auto_local(JObject::from(hostname.into_java(env)));
+                let country = country_code.into_java(env);
+                let city = city_code.into_java(env);
+                let hostname = hostname.into_java(env);
                 let parameters = [
                     JValue::Object(country.as_obj()),
                     JValue::Object(city.as_obj()),
@@ -576,7 +609,7 @@ where
                 )
                 .expect("Failed to create LocationConstraint.Hostname Java object")
             }
-        }
+        })
     }
 }
 
@@ -584,7 +617,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for RelaySettings
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         match self {
@@ -598,14 +631,16 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for CustomTunnelEndpoint
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class =
             env.get_class("net/mullvad/mullvadvpn/model/RelaySettings$CustomTunnelEndpoint");
 
-        env.new_object(&class, "()V", &[])
-            .expect("Failed to create CustomTunnelEndpoint Java object")
+        env.auto_local(
+            env.new_object(&class, "()V", &[])
+                .expect("Failed to create CustomTunnelEndpoint Java object"),
+        )
     }
 }
 
@@ -613,13 +648,13 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for KeygenEvent
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        match self {
+        env.auto_local(match self {
             KeygenEvent::NewKey(public_key) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/KeygenEvent$NewKey");
-                let java_public_key = env.auto_local(public_key.into_java(env));
+                let java_public_key = public_key.into_java(env);
 
                 let parameters = [
                     JValue::Object(java_public_key.as_obj()),
@@ -665,7 +700,7 @@ where
                 )
                 .expect("Failed to create KeygenEvent.GenerationFailure Java object")
             }
-        }
+        })
     }
 }
 
@@ -673,19 +708,21 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for RelayConstraints
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/RelaySettings$RelayConstraints");
-        let location = env.auto_local(self.location.into_java(env));
+        let location = self.location.into_java(env);
         let parameters = [JValue::Object(location.as_obj())];
 
-        env.new_object(
-            &class,
-            "(Lnet/mullvad/mullvadvpn/model/Constraint;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Lnet/mullvad/mullvadvpn/model/Constraint;)V",
+                &parameters,
+            )
+            .expect("Failed to create RelaySettings.RelayConstraints Java object"),
         )
-        .expect("Failed to create RelaySettings.RelayConstraints Java object")
     }
 }
 
@@ -693,23 +730,25 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Settings
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class = env.get_class("net/mullvad/mullvadvpn/model/Settings");
-        let account_token = env.auto_local(JObject::from(self.get_account_token().into_java(env)));
-        let relay_settings = env.auto_local(self.get_relay_settings().into_java(env));
+        let account_token = self.get_account_token().into_java(env);
+        let relay_settings = self.get_relay_settings().into_java(env);
         let parameters = [
             JValue::Object(account_token.as_obj()),
             JValue::Object(relay_settings.as_obj()),
         ];
 
-        env.new_object(
-            &class,
-            "(Ljava/lang/String;Lnet/mullvad/mullvadvpn/model/RelaySettings;)V",
-            &parameters,
+        env.auto_local(
+            env.new_object(
+                &class,
+                "(Ljava/lang/String;Lnet/mullvad/mullvadvpn/model/RelaySettings;)V",
+                &parameters,
+            )
+            .expect("Failed to create Settings Java object"),
         )
-        .expect("Failed to create Settings Java object")
     }
 }
 
@@ -717,7 +756,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for ActionAfterDisconnect
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let variant = match self {
@@ -731,8 +770,10 @@ where
         );
         let class = env.get_class(&class_name);
 
-        env.new_object(&class, "()V", &[])
-            .expect("Failed to create ActionAfterDisconnect sub-class variant Java object")
+        env.auto_local(
+            env.new_object(&class, "()V", &[])
+                .expect("Failed to create ActionAfterDisconnect sub-class variant Java object"),
+        )
     }
 }
 
@@ -740,18 +781,19 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for BlockReason
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let variant = match self {
             BlockReason::AuthFailed(reason) => {
                 let class = env.get_class("net/mullvad/talpid/tunnel/BlockReason$AuthFailed");
-                let reason = env.auto_local(JObject::from(reason.into_java(env)));
+                let reason = reason.into_java(env);
                 let parameters = [JValue::Object(reason.as_obj())];
 
-                return env
-                    .new_object(&class, "(Ljava/lang/String;)V", &parameters)
-                    .expect("Failed to create BlockReason.AuthFailed Java object");
+                return env.auto_local(
+                    env.new_object(&class, "(Ljava/lang/String;)V", &parameters)
+                        .expect("Failed to create BlockReason.AuthFailed Java object"),
+                );
             }
             BlockReason::Ipv6Unavailable => "Ipv6Unavailable",
             BlockReason::SetFirewallPolicyError => "SetFirewallPolicyError",
@@ -760,15 +802,16 @@ where
             BlockReason::TunnelParameterError(reason) => {
                 let class =
                     env.get_class("net/mullvad/talpid/tunnel/BlockReason$ParameterGeneration");
-                let reason = env.auto_local(JObject::from(reason.into_java(env)));
+                let reason = reason.into_java(env);
                 let parameters = [JValue::Object(reason.as_obj())];
-                return env
-                    .new_object(
+                return env.auto_local(
+                    env.new_object(
                         &class,
                         "(Lnet/mullvad/talpid/tunnel/ParameterGenerationError;)V",
                         &parameters,
                     )
-                    .expect("Failed to create BlockReason.ParameterGeneration Java object");
+                    .expect("Failed to create BlockReason.ParameterGeneration Java object"),
+                );
             }
             BlockReason::IsOffline => "IsOffline",
             BlockReason::TapAdapterProblem => "TapAdapterProblem",
@@ -776,8 +819,10 @@ where
         let class_name = format!("net/mullvad/talpid/tunnel/BlockReason${}", variant);
         let class = env.get_class(&class_name);
 
-        env.new_object(&class, "()V", &[])
-            .expect("Failed to create BlockReason sub-class variant Java object")
+        env.auto_local(
+            env.new_object(&class, "()V", &[])
+                .expect("Failed to create BlockReason sub-class variant Java object"),
+        )
     }
 }
 
@@ -785,7 +830,7 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for ParameterGenerationError
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
         let class_variant = match self {
@@ -801,8 +846,10 @@ where
             class_variant
         );
         let class = env.get_class(&class_name);
-        env.new_object(&class, "()V", &[])
-            .expect("Failed to create ParameterGenerationError sub-class variant Java object")
+        env.auto_local(
+            env.new_object(&class, "()V", &[])
+                .expect("Failed to create ParameterGenerationError sub-class variant Java object"),
+        )
     }
 }
 
@@ -810,10 +857,10 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for TunnelState
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        match self {
+        env.auto_local(match self {
             TunnelState::Disconnected => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/TunnelState$Disconnected");
 
@@ -821,8 +868,8 @@ where
             }
             TunnelState::Connecting { endpoint, location } => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/TunnelState$Connecting");
-                let endpoint = env.auto_local(endpoint.into_java(env));
-                let location = env.auto_local(location.into_java(env));
+                let endpoint = endpoint.into_java(env);
+                let location = location.into_java(env);
                 let parameters = [
                     JValue::Object(endpoint.as_obj()),
                     JValue::Object(location.as_obj()),
@@ -834,8 +881,8 @@ where
             }
             TunnelState::Connected { endpoint, location } => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/TunnelState$Connected");
-                let endpoint = env.auto_local(endpoint.into_java(env));
-                let location = env.auto_local(location.into_java(env));
+                let endpoint = endpoint.into_java(env);
+                let location = location.into_java(env);
                 let parameters = [
                     JValue::Object(endpoint.as_obj()),
                     JValue::Object(location.as_obj()),
@@ -847,7 +894,7 @@ where
             }
             TunnelState::Disconnecting(action_after_disconnect) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/TunnelState$Disconnecting");
-                let after_disconnect = env.auto_local(action_after_disconnect.into_java(env));
+                let after_disconnect = action_after_disconnect.into_java(env);
                 let parameters = [JValue::Object(after_disconnect.as_obj())];
                 let signature = "(Lnet/mullvad/talpid/tunnel/ActionAfterDisconnect;)V";
 
@@ -855,14 +902,14 @@ where
             }
             TunnelState::Blocked(block_reason) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/TunnelState$Blocked");
-                let reason = env.auto_local(block_reason.into_java(env));
+                let reason = block_reason.into_java(env);
                 let parameters = [JValue::Object(reason.as_obj())];
                 let signature = "(Lnet/mullvad/talpid/tunnel/BlockReason;)V";
 
                 env.new_object(&class, signature, &parameters)
             }
         }
-        .expect("Failed to create TunnelState sub-class variant Java object")
+        .expect("Failed to create TunnelState sub-class variant Java object"))
     }
 }
 
@@ -870,13 +917,13 @@ impl<'borrow, 'env> IntoJava<'borrow, 'env> for Result<AccountData, daemon_inter
 where
     'env: 'borrow,
 {
-    type JavaType = JObject<'env>;
+    type JavaType = AutoLocal<'env, 'borrow>;
 
     fn into_java(self, env: &'borrow JnixEnv<'env>) -> Self::JavaType {
-        match self {
+        env.auto_local(match self {
             Ok(data) => {
                 let class = env.get_class("net/mullvad/mullvadvpn/model/GetAccountDataResult$Ok");
-                let java_account_data = env.auto_local(data.into_java(&env));
+                let java_account_data = data.into_java(&env);
                 let parameters = [JValue::Object(java_account_data.as_obj())];
 
                 env.new_object(
@@ -905,6 +952,6 @@ where
                 env.new_object(&class, "()V", &[])
                     .expect("Failed to create a GetAccountDataResult error sub-class Java object")
             }
-        }
+        })
     }
 }
diff --git a/mullvad-jni/src/jni_event_listener.rs b/mullvad-jni/src/jni_event_listener.rs
index 7db6f2cdbd..234fd30313 100644
--- a/mullvad-jni/src/jni_event_listener.rs
+++ b/mullvad-jni/src/jni_event_listener.rs
@@ -186,7 +186,7 @@ impl<'env> JniEventHandler<'env> {
     }
 
     fn handle_keygen_event(&self, event: KeygenEvent) {
-        let java_keygen_event = self.env.auto_local(event.into_java(&self.env));
+        let java_keygen_event = event.into_java(&self.env);
 
         let result = self.env.call_method_unchecked(
             self.mullvad_ipc_client,
@@ -204,7 +204,7 @@ impl<'env> JniEventHandler<'env> {
     }
 
     fn handle_relay_list_event(&self, relay_list: RelayList) {
-        let java_relay_list = self.env.auto_local(relay_list.into_java(&self.env));
+        let java_relay_list = relay_list.into_java(&self.env);
 
         let result = self.env.call_method_unchecked(
             self.mullvad_ipc_client,
@@ -222,7 +222,7 @@ impl<'env> JniEventHandler<'env> {
     }
 
     fn handle_settings(&self, settings: Settings) {
-        let java_settings = self.env.auto_local(settings.into_java(&self.env));
+        let java_settings = settings.into_java(&self.env);
 
         let result = self.env.call_method_unchecked(
             self.mullvad_ipc_client,
@@ -240,7 +240,7 @@ impl<'env> JniEventHandler<'env> {
     }
 
     fn handle_tunnel_event(&self, event: TunnelState) {
-        let java_tunnel_state = self.env.auto_local(event.into_java(&self.env));
+        let java_tunnel_state = event.into_java(&self.env);
 
         let result = self.env.call_method_unchecked(
             self.mullvad_ipc_client,
@@ -258,7 +258,7 @@ impl<'env> JniEventHandler<'env> {
     }
 
     fn handle_app_version_info_event(&self, app_version_info: AppVersionInfo) {
-        let java_app_version_info = self.env.auto_local(app_version_info.into_java(&self.env));
+        let java_app_version_info = app_version_info.into_java(&self.env);
 
         let result = self.env.call_method_unchecked(
             self.mullvad_ipc_client,
diff --git a/mullvad-jni/src/lib.rs b/mullvad-jni/src/lib.rs
index dd6ee21a7a..4e8fc7d03e 100644
--- a/mullvad-jni/src/lib.rs
+++ b/mullvad-jni/src/lib.rs
@@ -189,7 +189,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_generateWiregua
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.generate_wireguard_key() {
-        Ok(keygen_event) => keygen_event.into_java(&env),
+        Ok(keygen_event) => keygen_event.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
@@ -244,7 +244,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getAccountData<
         );
     }
 
-    result.into_java(&env)
+    result.into_java(&env).forget()
 }
 
 #[no_mangle]
@@ -252,17 +252,17 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getAccountData<
 pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getWwwAuthToken<'env, 'this>(
     env: JNIEnv<'env>,
     _: JObject<'this>,
-) -> JString<'env> {
+) -> JObject<'env> {
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_www_auth_token() {
-        Ok(token) => token.into_java(&env),
+        Ok(token) => token.into_java(&env).forget(),
         Err(err) => {
             log::error!(
                 "{}",
                 err.display_chain_with_msg("Failed to get WWW auth token")
             );
-            String::new().into_java(&env)
+            String::new().into_java(&env).forget()
         }
     }
 }
@@ -276,7 +276,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getCurrentLocat
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_current_location() {
-        Ok(location) => location.into_java(&env),
+        Ok(location) => location.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
@@ -292,17 +292,17 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getCurrentLocat
 pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getCurrentVersion<'env, 'this>(
     env: JNIEnv<'env>,
     _: JObject<'this>,
-) -> JString<'env> {
+) -> JObject<'env> {
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_current_version() {
-        Ok(location) => location.into_java(&env),
+        Ok(location) => location.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
                 error.display_chain_with_msg("Failed to get current version")
             );
-            String::new().into_java(&env)
+            String::new().into_java(&env).forget()
         }
     }
 }
@@ -316,7 +316,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getRelayLocatio
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_relay_locations() {
-        Ok(relay_list) => relay_list.into_java(&env),
+        Ok(relay_list) => relay_list.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
@@ -336,7 +336,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getSettings<'en
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_settings() {
-        Ok(settings) => settings.into_java(&env),
+        Ok(settings) => settings.into_java(&env).forget(),
         Err(error) => {
             log::error!("{}", error.display_chain_with_msg("Failed to get settings"));
             JObject::null()
@@ -353,7 +353,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getState<'env,
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_state() {
-        Ok(state) => state.into_java(&env),
+        Ok(state) => state.into_java(&env).forget(),
         Err(error) => {
             log::error!("{}", error.display_chain_with_msg("Failed to get state"));
             JObject::null()
@@ -370,7 +370,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getVersionInfo<
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_version_info() {
-        Ok(version_info) => version_info.into_java(&env),
+        Ok(version_info) => version_info.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
@@ -390,7 +390,7 @@ pub extern "system" fn Java_net_mullvad_mullvadvpn_MullvadDaemon_getWireguardKey
     let env = JnixEnv::from(env);
 
     match DAEMON_INTERFACE.get_wireguard_key() {
-        Ok(key) => key.into_java(&env),
+        Ok(key) => key.into_java(&env).forget(),
         Err(error) => {
             log::error!(
                 "{}",
diff --git a/mullvad-jni/src/vpn_service_tun_provider.rs b/mullvad-jni/src/vpn_service_tun_provider.rs
index 9415087a1f..aecdee3786 100644
--- a/mullvad-jni/src/vpn_service_tun_provider.rs
+++ b/mullvad-jni/src/vpn_service_tun_provider.rs
@@ -119,7 +119,7 @@ impl VpnServiceTunProvider {
             )
             .map_err(|cause| Error::FindMethod("createTun", cause))?;
 
-        let java_config = env.auto_local(config.clone().into_java(&env));
+        let java_config = config.clone().into_java(&env);
         let result = env
             .call_method_unchecked(
                 self.object.as_obj(),