Support uncached paths RRO

A new Runtime Resource Overlay config_supported_uncached_relative_paths
specifies the paths that should always be accessed without caching.

The config can be used to avoid cache synchronization issues when a
specific path can be accessed from its lower filesystem.

As the name suggests, each item must be specified as a path relative to
the mount point's root. Also, it's assumed to point to a directory and
must end with a slash '/'.

By default, the config array is empty.

Bug: 208964465
Test: Add a relative path to config_supported_uncached_relative_paths
      and confirm that files under the path is accessed without caching.
Test: atest com.android.providers.media.util.StringUtilsTest

Change-Id: If13a3a108cae4c2893e57d9a763c6fd51d037509

1 files changed, 35 insertions, 21 deletions

diff --git a/jni/com_android_providers_media_FuseDaemon.cpp b/jni/com_android_providers_media_FuseDaemon.cpp
index 46ed04120..ca6cea968 100644
--- a/jni/com_android_providers_media_FuseDaemon.cpp
+++ b/jni/com_android_providers_media_FuseDaemon.cpp
@@ -33,28 +33,38 @@ namespace {
 constexpr const char* CLASS_NAME = "com/android/providers/media/fuse/FuseDaemon";
 static jclass gFuseDaemonClass;
 
-static std::vector<std::string> get_supported_transcoding_relative_paths(
-        JNIEnv* env, jobjectArray java_supported_transcoding_relative_paths) {
-    ScopedLocalRef<jobjectArray> j_transcoding_relative_paths(
-            env, java_supported_transcoding_relative_paths);
-    std::vector<std::string> transcoding_relative_paths;
-
-    const int transcoding_relative_paths_count =
-            env->GetArrayLength(j_transcoding_relative_paths.get());
-    for (int i = 0; i < transcoding_relative_paths_count; i++) {
-        ScopedLocalRef<jstring> j_ref_relative_path(
-                env, (jstring)env->GetObjectArrayElement(j_transcoding_relative_paths.get(), i));
-        ScopedUtfChars j_utf_relative_path(env, j_ref_relative_path.get());
-        const char* relative_path = j_utf_relative_path.c_str();
-
-        if (relative_path) {
-            transcoding_relative_paths.push_back(relative_path);
+static std::vector<std::string> convert_object_array_to_string_vector(
+        JNIEnv* env, jobjectArray java_object_array, const std::string& element_description) {
+    ScopedLocalRef<jobjectArray> j_ref_object_array(env, java_object_array);
+    std::vector<std::string> utf_strings;
+
+    const int object_array_length = env->GetArrayLength(j_ref_object_array.get());
+    for (int i = 0; i < object_array_length; i++) {
+        ScopedLocalRef<jstring> j_ref_string(
+                env, (jstring)env->GetObjectArrayElement(j_ref_object_array.get(), i));
+        ScopedUtfChars utf_chars(env, j_ref_string.get());
+        const char* utf_string = utf_chars.c_str();
+
+        if (utf_string) {
+            utf_strings.push_back(utf_string);
         } else {
-            LOG(ERROR) << "Error reading supported transcoding relative path at index: " << i;
+            LOG(ERROR) << "Error reading " << element_description << " at index: " << i;
         }
     }
 
-    return transcoding_relative_paths;
+    return utf_strings;
+}
+
+static std::vector<std::string> get_supported_transcoding_relative_paths(
+        JNIEnv* env, jobjectArray java_supported_transcoding_relative_paths) {
+    return convert_object_array_to_string_vector(env, java_supported_transcoding_relative_paths,
+                                                 "supported transcoding relative path");
+}
+
+static std::vector<std::string> get_supported_uncached_relative_paths(
+        JNIEnv* env, jobjectArray java_supported_uncached_relative_paths) {
+    return convert_object_array_to_string_vector(env, java_supported_uncached_relative_paths,
+                                                 "supported uncached relative path");
 }
 
 jlong com_android_providers_media_FuseDaemon_new(JNIEnv* env, jobject self,
@@ -65,7 +75,8 @@ jlong com_android_providers_media_FuseDaemon_new(JNIEnv* env, jobject self,
 
 void com_android_providers_media_FuseDaemon_start(
         JNIEnv* env, jobject self, jlong java_daemon, jint fd, jstring java_path,
-        jobjectArray java_supported_transcoding_relative_paths) {
+        jobjectArray java_supported_transcoding_relative_paths,
+        jobjectArray java_supported_uncached_relative_paths) {
     LOG(DEBUG) << "Starting the FUSE daemon...";
     fuse::FuseDaemon* const daemon = reinterpret_cast<fuse::FuseDaemon*>(java_daemon);
 
@@ -79,8 +90,11 @@ void com_android_providers_media_FuseDaemon_start(
     const std::vector<std::string>& transcoding_relative_paths =
             get_supported_transcoding_relative_paths(env,
                     java_supported_transcoding_relative_paths);
+    const std::vector<std::string>& uncached_relative_paths =
+            get_supported_uncached_relative_paths(env, java_supported_uncached_relative_paths);
 
-    daemon->Start(std::move(ufd), utf_chars_path.c_str(), transcoding_relative_paths);
+    daemon->Start(std::move(ufd), utf_chars_path.c_str(), transcoding_relative_paths,
+                  uncached_relative_paths);
 }
 
 bool com_android_providers_media_FuseDaemon_is_started(JNIEnv* env, jobject self,
@@ -157,7 +171,7 @@ bool com_android_providers_media_FuseDaemon_is_fuse_thread(JNIEnv* env, jclass c
 const JNINativeMethod methods[] = {
         {"native_new", "(Lcom/android/providers/media/MediaProvider;)J",
          reinterpret_cast<void*>(com_android_providers_media_FuseDaemon_new)},
-        {"native_start", "(JILjava/lang/String;[Ljava/lang/String;)V",
+        {"native_start", "(JILjava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
          reinterpret_cast<void*>(com_android_providers_media_FuseDaemon_start)},
         {"native_delete", "(J)V",
          reinterpret_cast<void*>(com_android_providers_media_FuseDaemon_delete)},