feat(kotlin): pass http cacache dir in initializeNative

feat(kotlin): make sure cacache dir is writable

Signed-off-by: Lachezar Lechev <lachezar@ambire.com>

Author: elpiel

stremio-core-kotlin/src/commonMain/rust/env/fetch.rs

@@ -1,7 +1,7 @@
 use std::{
     convert::TryFrom,
-    env::{self, VarError},
-    path::PathBuf,
+    fs,
+    path::{Path, PathBuf},
     time::Duration,
 };
 
@@ -15,9 +15,27 @@ use serde::{Deserialize, Serialize};
 use serde_json::Deserializer;
 use stremio_core::runtime::{EnvError, EnvFutureExt, TryEnvFuture};
 
+use crate::CACHE_DIR;
+
 static CLIENT_WITH_CACHE: OnceCell<ClientWithMiddleware> = OnceCell::new();
 static CLIENT_WITHOUT_CACHE: OnceCell<ClientWithMiddleware> = OnceCell::new();
 
+/// 1. Creates all directories for the path if they don't exist
+/// 2. writes a test file to see if the app has write permission
+/// 3. deletes the file to clean up and check delete permission
+fn ensure_cache_dir_permissions(path: &Path) -> std::io::Result<()> {
+    // Ensure directory exists
+    fs::create_dir_all(path)?;
+
+    // Attempt to create a temp file
+    let test_file = path.join(".cache_permission_test");
+    fs::write(&test_file, b"test")?;
+
+    // Attempt to delete it
+    fs::remove_file(&test_file)?;
+    Ok(())
+}
+
 pub fn fetch<IN: Serialize + Send + 'static, OUT: for<'de> Deserialize<'de> + Send + 'static>(
     request: Request<IN>,
 ) -> TryEnvFuture<OUT> {
@@ -33,48 +51,49 @@ pub fn fetch<IN: Serialize + Send + 'static, OUT: for<'de> Deserialize<'de> + Se
         Err(error) => return future::err(EnvError::Fetch(error.to_string())).boxed_env(),
     };
 
-    let client = match env::var("TMPDIR") {
-        Ok(tmpdir) => {
-            CLIENT_WITH_CACHE.get_or_init(|| {
-                let tmpdir_path = PathBuf::from(tmpdir);
-                let cacache_path = tmpdir_path.join("http-cacache");
-                let connection_timeout = Duration::from_secs(30);
+    let fut = async {
+        // should always be set as we set it on initializeNative
+        let client = CACHE_DIR.get().cloned().flatten().and_then(|cache_dir| {
+            let cacache_path = PathBuf::from(cache_dir);
+
+            match ensure_cache_dir_permissions(&cacache_path) {
+                Ok(_) => {
 
-                tracing::info!(tmpdir_path = %tmpdir_path.display(), cacache_path = %cacache_path.display(), ?connection_timeout, "Client Cacache middleware will be initialized...");
+                    let cacache_manager = CACacheManager { path: cacache_path.clone() };
+
+                    Some(CLIENT_WITH_CACHE.get_or_init(|| {
+                        let connection_timeout = Duration::from_secs(30);
+
+                        tracing::info!(cacache_path = %cacache_path.display(), ?connection_timeout, "Client CACache middleware will be initialized...");
+                        ClientBuilder::new(
+                            Client::builder()
+                                .connect_timeout(connection_timeout)
+                                .use_rustls_tls()
+                                .build()
+                                .unwrap_or_default(),
+                        )
+                        .with(Cache(HttpCache {
+                            mode: CacheMode::Default,
+                            manager: cacache_manager,
+                            options: HttpCacheOptions::default(),
+                        }))
+                        .build()
+                    }))
+                },
+                Err(_) => None,
+            }
+            }).unwrap_or_else(|| { CLIENT_WITHOUT_CACHE.get_or_init(|| {
                 ClientBuilder::new(
                     Client::builder()
-                        .connect_timeout(connection_timeout)
+                        .connect_timeout(Duration::from_secs(30))
                         .use_rustls_tls()
                         .build()
                         .unwrap_or_default(),
                 )
-                .with(Cache(HttpCache::<CACacheManager> {
-                    mode: CacheMode::Default,
-                    manager: CACacheManager {
-                        path: cacache_path,
-                    },
-                    options: HttpCacheOptions::default(),
-                }))
                 .build()
             })
-        }
-        Err(err) => CLIENT_WITHOUT_CACHE.get_or_init(|| {
-            // we log the error only once when initializing the Client.
-            if let VarError::NotUnicode(_) = &err {
-                tracing::error!(?err, "TMPDIR env. variable is not a valid Unicode, no Client Cacache middleware will be used");
-            }
-            ClientBuilder::new(
-                Client::builder()
-                    .connect_timeout(Duration::from_secs(30))
-                    .use_rustls_tls()
-                    .build()
-                    .unwrap_or_default(),
-            )
-            .build()
-        })
-    };
+        });
 
-    let fut = async {
         let resp = client
             .execute(request)
             .map_err(|error| EnvError::Fetch(error.to_string()))

stremio-core-kotlin/src/commonMain/rust/stremio_core_kotlin.rs

@@ -6,12 +6,12 @@ use std::{io::Cursor, os::raw::c_void, sync::RwLock};
 use enclose::enclose;
 use futures::{future, StreamExt};
 use jni::{
-    objects::{JClass, JObject},
+    objects::{JClass, JObject, JString},
     sys::{jbyteArray, jint, jobject, JNI_VERSION_1_6},
     JNIEnv, JavaVM,
 };
 
-use once_cell::sync::Lazy;
+use once_cell::sync::{Lazy, OnceCell};
 use prost::Message;
 
 use stremio_core::{
@@ -47,6 +47,9 @@ pub mod subscriber;
 static RUNTIME: Lazy<RwLock<Option<Loadable<Runtime<AndroidEnv, AndroidModel>, EnvError>>>> =
     Lazy::new(Default::default);
 
+/// The CACache directory on [`Java_com_stremio_core_Core_initializeNative`] of `stremio-core-kotlin`.
+pub static CACHE_DIR: OnceCell<Option<String>> = OnceCell::new();
+
 /// Initialize panic hook to send data to Kotlin
 #[no_mangle]
 pub unsafe extern "C" fn JNI_OnLoad(_: JavaVM, _: *mut c_void) -> jint {
@@ -94,11 +97,30 @@ pub unsafe extern "C" fn Java_com_stremio_core_Core_initializeNative(
     env: JNIEnv,
     _class: JClass,
     storage: JObject,
+    cache_dir: JString,
 ) -> jobject {
     if RUNTIME.read().expect("RUNTIME read failed").is_some() {
         return JObject::null().into_inner();
     };
 
+    {
+        let cache_dir: Option<String> = match env.get_string(cache_dir) {
+            Ok(java_str) => Some(java_str.into()),
+            // if null, disable cache
+            Err(jni::errors::Error::NullPtr(_)) => None,
+            // on any other error, log it and continue
+            Err(err) => {
+                error!(?err, "The passed cache dir failed to be converted to a string, no caching will be used for requests");
+                None
+            }
+        };
+
+        // Set the cache directory only once on initialization!
+        CACHE_DIR
+            .set(cache_dir)
+            .expect("Cache directory should be set only once!");
+    }
+
     let init_result = AndroidEnv::exec_sync(AndroidEnv::init(&env, storage));
     match init_result {
         Ok(_) => {

stremio-core-kotlin/src/commonMain/rust/stremio_core_kotlin/subscriber.rs

@@ -1,5 +1,4 @@
 //! A `tracing` subscriber for Kotlin.
-//!
 
 use core::fmt::{self, Write};