Merge pull request #9318 from JosJuice/android-saf-games

Android: Use storage access framework for game list

Source/Core/Common/FileSearch.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <iterator>
 
 #include "Common/CommonPaths.h"
 #include "Common/FileSearch.h"
@@ -15,6 +16,10 @@
 namespace fs = std::filesystem;
 #define HAS_STD_FILESYSTEM
 #else
+#ifdef ANDROID
+#include "jni/AndroidCommon/AndroidCommon.h"
+#endif
+
 #include <cstring>
 #include "Common/CommonFuncs.h"
 #include "Common/FileUtil.h"
@@ -24,36 +29,30 @@ namespace Common
 {
 #ifndef HAS_STD_FILESYSTEM
 
-static std::vector<std::string>
-FileSearchWithTest(const std::vector<std::string>& directories, bool recursive,
-                   std::function<bool(const File::FSTEntry&)> callback)
+static void FileSearchWithTest(const std::string& directory, bool recursive,
+                               std::vector<std::string>* result_out,
+                               std::function<bool(const File::FSTEntry&)> callback)
 {
-  std::vector<std::string> result;
-  for (const std::string& directory : directories)
-  {
-    File::FSTEntry top = File::ScanDirectoryTree(directory, recursive);
+  File::FSTEntry top = File::ScanDirectoryTree(directory, recursive);
 
-    std::function<void(File::FSTEntry&)> DoEntry;
-    DoEntry = [&](File::FSTEntry& entry) {
-      if (callback(entry))
-        result.push_back(entry.physicalName);
-      for (auto& child : entry.children)
-        DoEntry(child);
-    };
-    for (auto& child : top.children)
+  const std::function<void(File::FSTEntry&)> DoEntry = [&](File::FSTEntry& entry) {
+    if (callback(entry))
+      result_out->push_back(entry.physicalName);
+    for (auto& child : entry.children)
       DoEntry(child);
-  }
-  // remove duplicates
-  std::sort(result.begin(), result.end());
-  result.erase(std::unique(result.begin(), result.end()), result.end());
-  return result;
+  };
+
+  for (auto& child : top.children)
+    DoEntry(child);
 }
 
 std::vector<std::string> DoFileSearch(const std::vector<std::string>& directories,
                                       const std::vector<std::string>& exts, bool recursive)
 {
+  std::vector<std::string> result;
+
   bool accept_all = exts.empty();
-  return FileSearchWithTest(directories, recursive, [&](const File::FSTEntry& entry) {
+  const auto callback = [&exts, accept_all](const File::FSTEntry& entry) {
     if (accept_all)
       return true;
     if (entry.isDirectory)
@@ -63,7 +62,34 @@ std::vector<std::string> DoFileSearch(const std::vector<std::string>& directorie
       return name.length() >= ext.length() &&
              strcasecmp(name.c_str() + name.length() - ext.length(), ext.c_str()) == 0;
     });
-  });
+  };
+
+  for (const std::string& directory : directories)
+  {
+#ifdef ANDROID
+    // While File::ScanDirectoryTree (which is called in FileSearchWithTest) does handle Android
+    // content correctly, having a specialized implementation of DoFileSearch for Android content
+    // provides a much needed performance boost. Also, this specialized implementation will be
+    // required if we in the future replace the use of File::ScanDirectoryTree with std::filesystem.
+    if (IsPathAndroidContent(directory))
+    {
+      const std::vector<std::string> partial_result =
+          DoFileSearchAndroidContent(directory, exts, recursive);
+
+      result.insert(result.end(), std::make_move_iterator(partial_result.begin()),
+                    std::make_move_iterator(partial_result.end()));
+    }
+    else
+#endif
+    {
+      FileSearchWithTest(directory, recursive, &result, callback);
+    }
+  }
+
+  // remove duplicates
+  std::sort(result.begin(), result.end());
+  result.erase(std::unique(result.begin(), result.end()), result.end());
+  return result;
 }
 
 #else

Source/Core/Common/FileUtil.cpp

@@ -78,19 +78,40 @@ FileInfo::FileInfo(const char* path) : FileInfo(std::string(path))
 #else
 FileInfo::FileInfo(const std::string& path) : FileInfo(path.c_str())
 {
+#ifdef ANDROID
+  if (IsPathAndroidContent(path))
+    AndroidContentInit(path);
+  else
+#endif
+    m_exists = stat(path.c_str(), &m_stat) == 0;
 }
 
 FileInfo::FileInfo(const char* path)
 {
-  m_exists = stat(path, &m_stat) == 0;
+#ifdef ANDROID
+  if (IsPathAndroidContent(path))
+    AndroidContentInit(path);
+  else
+#endif
+    m_exists = stat(path, &m_stat) == 0;
 }
 #endif
 
 FileInfo::FileInfo(int fd)
 {
-  m_exists = fstat(fd, &m_stat);
+  m_exists = fstat(fd, &m_stat) == 0;
 }
 
+#ifdef ANDROID
+void FileInfo::AndroidContentInit(const std::string& path)
+{
+  const jlong result = GetAndroidContentSizeAndIsDirectory(path);
+  m_exists = result != -1;
+  m_stat.st_mode = result == -2 ? S_IFDIR : S_IFREG;
+  m_stat.st_size = result >= 0 ? result : 0;
+}
+#endif
+
 bool FileInfo::Exists() const
 {
   return m_exists;
@@ -476,14 +497,47 @@ FSTEntry ScanDirectoryTree(const std::string& directory, bool recursive)
   {
     const std::string virtual_name(TStrToUTF8(ffd.cFileName));
 #else
-  DIR* dirp = opendir(directory.c_str());
-  if (!dirp)
-    return parent_entry;
+  DIR* dirp = nullptr;
+
+#ifdef ANDROID
+  std::vector<std::string> child_names;
+  if (IsPathAndroidContent(directory))
+  {
+    child_names = GetAndroidContentChildNames(directory);
+  }
+  else
+#endif
+  {
+    dirp = opendir(directory.c_str());
+    if (!dirp)
+      return parent_entry;
+  }
+
+#ifdef ANDROID
+  auto it = child_names.cbegin();
+#endif
 
   // non Windows loop
-  while (dirent* result = readdir(dirp))
+  while (true)
   {
-    const std::string virtual_name(result->d_name);
+    std::string virtual_name;
+
+#ifdef ANDROID
+    if (!dirp)
+    {
+      if (it == child_names.cend())
+        break;
+      virtual_name = *it;
+      ++it;
+    }
+    else
+#endif
+    {
+      dirent* result = readdir(dirp);
+      if (!result)
+        break;
+      virtual_name = result->d_name;
+    }
 #endif
     if (virtual_name == "." || virtual_name == "..")
       continue;
@@ -514,7 +568,8 @@ FSTEntry ScanDirectoryTree(const std::string& directory, bool recursive)
   FindClose(hFind);
 #else
   }
-  closedir(dirp);
+  if (dirp)
+    closedir(dirp);
 #endif
 
   return parent_entry;

Source/Core/Common/FileUtil.h

@@ -18,6 +18,11 @@
 #include "Common/StringUtil.h"
 #endif
 
+#ifdef ANDROID
+#include "Common/StringUtil.h"
+#include "jni/AndroidCommon/AndroidCommon.h"
+#endif
+
 // User directory indices for GetUserPath
 enum
 {
@@ -109,6 +114,10 @@ public:
   u64 GetSize() const;
 
 private:
+#ifdef ANDROID
+  void AndroidContentInit(const std::string& path);
+#endif
+
   struct stat m_stat;
   bool m_exists;
 };
@@ -214,14 +223,20 @@ std::string GetExeDirectory();
 bool WriteStringToFile(const std::string& filename, std::string_view str);
 bool ReadFileToString(const std::string& filename, std::string& str);
 
-// To deal with Windows being dumb at unicode:
+// To deal with Windows not fully supporting UTF-8 and Android not fully supporting paths.
 template <typename T>
 void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode)
 {
 #ifdef _WIN32
   fstream.open(UTF8ToTStr(filename).c_str(), openmode);
 #else
-  fstream.open(filename.c_str(), openmode);
+#ifdef ANDROID
+  // Unfortunately it seems like the non-standard __open is the only way to use a file descriptor
+  if (IsPathAndroidContent(filename))
+    fstream.__open(OpenAndroidContent(filename, OpenModeToAndroid(openmode)), openmode);
+  else
+#endif
+    fstream.open(filename.c_str(), openmode);
 #endif
 }