Merge changes from topic "res_loader_dir" into rvc-dev am: b0544a733c

Change-Id: I18c28c7293a24d712940c9e80e7817f9547512f8

3 files changed, 130 insertions, 63 deletions

diff --git a/libs/androidfw/include/androidfw/ApkAssets.h b/libs/androidfw/include/androidfw/ApkAssets.h
index af802b0e50b9..879b050b65bd 100644
--- a/libs/androidfw/include/androidfw/ApkAssets.h
+++ b/libs/androidfw/include/androidfw/ApkAssets.h
@@ -35,62 +35,98 @@ namespace android {
 
 class LoadedIdmap;
 
+// Interface for retrieving assets provided by an ApkAssets.
+class AssetsProvider {
+ public:
+  virtual ~AssetsProvider() = default;
+
+  // Opens a file for reading.
+  std::unique_ptr<Asset> Open(const std::string& path,
+                              Asset::AccessMode mode = Asset::AccessMode::ACCESS_RANDOM,
+                              bool* file_exists = nullptr) const {
+    return OpenInternal(path, mode, file_exists);
+  }
+
+  // Iterate over all files and directories provided by the zip. The order of iteration is stable.
+  virtual bool ForEachFile(const std::string& /* path */,
+                           const std::function<void(const StringPiece&, FileType)>& /* f */) const {
+    return true;
+  }
+
+ protected:
+  AssetsProvider() = default;
+
+  virtual std::unique_ptr<Asset> OpenInternal(const std::string& path,
+                                              Asset::AccessMode mode,
+                                              bool* file_exists) const = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AssetsProvider);
+};
+
+class ZipAssetsProvider;
+
 // Holds an APK.
 class ApkAssets {
  public:
+  // This means the data extends to the end of the file.
+  static constexpr off64_t kUnknownLength = -1;
+
   // Creates an ApkAssets.
   // If `system` is true, the package is marked as a system package, and allows some functions to
   // filter out this package when computing what configurations/resources are available.
-  static std::unique_ptr<const ApkAssets> Load(const std::string& path, bool system = false,
-                                               bool for_loader = false);
+  static std::unique_ptr<const ApkAssets> Load(
+      const std::string& path, package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr);
 
-  // Creates an ApkAssets, but forces any package with ID 0x7f to be loaded as a shared library.
-  // If `system` is true, the package is marked as a system package, and allows some functions to
-  // filter out this package when computing what configurations/resources are available.
-  static std::unique_ptr<const ApkAssets> LoadAsSharedLibrary(const std::string& path,
-                                                              bool system = false);
+  // Creates an ApkAssets from the given file descriptor, and takes ownership of the file
+  // descriptor. The `friendly_name` is some name that will be used to identify the source of
+  // this ApkAssets in log messages and other debug scenarios.
+  // If `length` equals kUnknownLength, offset must equal 0; otherwise, the apk data will be read
+  // using the `offset` into the file descriptor and will be `length` bytes long.
+  static std::unique_ptr<const ApkAssets> LoadFromFd(
+      base::unique_fd fd, const std::string& friendly_name, package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr, off64_t offset = 0,
+      off64_t length = kUnknownLength);
+
+  // Creates an ApkAssets from the given path which points to a resources.arsc.
+  static std::unique_ptr<const ApkAssets> LoadTable(
+      const std::string& path, package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr);
+
+  // Creates an ApkAssets from the given file descriptor which points to an resources.arsc, and
+  // takes ownership of the file descriptor.
+  // If `length` equals kUnknownLength, offset must equal 0; otherwise, the .arsc data will be read
+  // using the `offset` into the file descriptor and will be `length` bytes long.
+  static std::unique_ptr<const ApkAssets> LoadTableFromFd(
+      base::unique_fd fd, const std::string& friendly_name, package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr, off64_t offset = 0,
+      off64_t length = kUnknownLength);
 
   // Creates an ApkAssets from an IDMAP, which contains the original APK path, and the overlay
   // data.
-  // If `system` is true, the package is marked as a system package, and allows some functions to
-  // filter out this package when computing what configurations/resources are available.
   static std::unique_ptr<const ApkAssets> LoadOverlay(const std::string& idmap_path,
-                                                      bool system = false);
+                                                      package_property_t flags = 0U);
 
-  // Creates an ApkAssets from the given file descriptor, and takes ownership of the file
-  // descriptor. The `friendly_name` is some name that will be used to identify the source of
-  // this ApkAssets in log messages and other debug scenarios.
-  // If `system` is true, the package is marked as a system package, and allows some functions to
-  // filter out this package when computing what configurations/resources are available.
-  // If `force_shared_lib` is true, any package with ID 0x7f is loaded as a shared library.
-  static std::unique_ptr<const ApkAssets> LoadFromFd(base::unique_fd fd,
-                                                     const std::string& friendly_name, bool system,
-                                                     bool force_shared_lib,
-                                                     bool for_loader = false);
-
-  // Creates an empty wrapper ApkAssets from the given path which points to an .arsc.
-  static std::unique_ptr<const ApkAssets> LoadArsc(const std::string& path,
-                                                   bool for_loader = false);
-
-  // Creates an empty wrapper ApkAssets from the given file descriptor which points to an .arsc,
-  // Takes ownership of the file descriptor.
-  static std::unique_ptr<const ApkAssets> LoadArsc(base::unique_fd fd,
-                                                   const std::string& friendly_name,
-                                                   bool for_loader = false);
+  // Creates an ApkAssets from the directory path. File-based resources are read within the
+  // directory as if the directory is an APK.
+  static std::unique_ptr<const ApkAssets> LoadFromDir(
+      const std::string& path, package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr);
 
   // Creates a totally empty ApkAssets with no resources table and no file entries.
-  static std::unique_ptr<const ApkAssets> LoadEmpty(bool for_loader = false);
-
-  std::unique_ptr<Asset> Open(const std::string& path,
-                              Asset::AccessMode mode = Asset::AccessMode::ACCESS_RANDOM) const;
-
-  bool ForEachFile(const std::string& path,
-                   const std::function<void(const StringPiece&, FileType)>& f) const;
+  static std::unique_ptr<const ApkAssets> LoadEmpty(
+      package_property_t flags = 0U,
+      std::unique_ptr<const AssetsProvider> override_asset = nullptr);
 
   inline const std::string& GetPath() const {
     return path_;
   }
 
+  inline const AssetsProvider* GetAssetsProvider() const {
+    return assets_provider_.get();
+  }
+
   // This is never nullptr.
   inline const LoadedArsc* GetLoadedArsc() const {
     return loaded_arsc_.get();
@@ -105,34 +141,44 @@ class ApkAssets {
   }
 
   inline bool IsOverlay() const {
-    return (property_flags_ & PROPERTY_OVERLAY) != 0;
+    return loaded_idmap_ != nullptr;
   }
 
   bool IsUpToDate() const;
 
-  // Creates an Asset from any file on the file system.
+  // Creates an Asset from a file on disk.
   static std::unique_ptr<Asset> CreateAssetFromFile(const std::string& path);
 
+  // Creates an Asset from a file descriptor.
+  //
+  // The asset takes ownership of the file descriptor. If `length` equals kUnknownLength, offset
+  // must equal 0; otherwise, the asset data will be read using the `offset` into the file
+  // descriptor and will be `length` bytes long.
+  static std::unique_ptr<Asset> CreateAssetFromFd(base::unique_fd fd,
+                                                  const char* path,
+                                                  off64_t offset = 0,
+                                                  off64_t length = kUnknownLength);
  private:
   DISALLOW_COPY_AND_ASSIGN(ApkAssets);
 
-  static std::unique_ptr<const ApkAssets> LoadImpl(base::unique_fd fd, const std::string& path,
-                                                   std::unique_ptr<Asset> idmap_asset,
-                                                   std::unique_ptr<const LoadedIdmap> loaded_idmap,
-                                                   package_property_t property_flags);
+  static std::unique_ptr<const ApkAssets> LoadImpl(
+      std::unique_ptr<const AssetsProvider> assets, const std::string& path,
+      package_property_t property_flags,
+      std::unique_ptr<const AssetsProvider> override_assets = nullptr,
+      std::unique_ptr<Asset> idmap_asset = nullptr,
+      std::unique_ptr<const LoadedIdmap> idmap  = nullptr);
 
-  static std::unique_ptr<const ApkAssets> LoadArscImpl(base::unique_fd fd,
-                                                       const std::string& path,
-                                                       package_property_t property_flags);
+  static std::unique_ptr<const ApkAssets> LoadTableImpl(
+      std::unique_ptr<Asset> resources_asset, const std::string& path,
+      package_property_t property_flags,
+      std::unique_ptr<const AssetsProvider> override_assets = nullptr);
 
-  ApkAssets(ZipArchiveHandle unmanaged_handle,
-            const std::string& path,
+  ApkAssets(std::unique_ptr<const AssetsProvider> assets_provider,
+            std::string path,
             time_t last_mod_time,
             package_property_t property_flags);
 
-  using ZipArchivePtr = std::unique_ptr<ZipArchive, void (*)(ZipArchiveHandle)>;
-
-  ZipArchivePtr zip_handle_;
+  std::unique_ptr<const AssetsProvider> assets_provider_;
   const std::string path_;
   time_t last_mod_time_;
   package_property_t property_flags_ = 0U;
diff --git a/libs/androidfw/include/androidfw/Asset.h b/libs/androidfw/include/androidfw/Asset.h
index 053dbb7864c6..298509eb37a1 100644
--- a/libs/androidfw/include/androidfw/Asset.h
+++ b/libs/androidfw/include/androidfw/Asset.h
@@ -26,6 +26,7 @@
 
 #include <memory>
 
+#include <android-base/unique_fd.h>
 #include <utils/Compat.h>
 #include <utils/Errors.h>
 #include <utils/String8.h>
@@ -158,6 +159,7 @@ private:
     /* AssetManager needs access to our "create" functions */
     friend class AssetManager;
     friend class ApkAssets;
+    friend class ZipAssetsProvider;
 
     /*
      * Create the asset from a named file on disk.
@@ -202,8 +204,14 @@ private:
      */
     static Asset* createFromUncompressedMap(FileMap* dataMap, AccessMode mode);
 
+    /*
+     * Create the asset from a memory-mapped file segment.
+     *
+     * The asset takes ownership of the FileMap and the file descriptor "fd". The file descriptor is
+     * used to request new file descriptors using "openFileDescriptor".
+     */
     static std::unique_ptr<Asset> createFromUncompressedMap(std::unique_ptr<FileMap> dataMap,
-        AccessMode mode);
+        base::unique_fd fd, AccessMode mode);
 
     /*
      * Create the asset from a memory-mapped file segment with compressed
@@ -256,9 +264,9 @@ public:
     /*
      * Use a memory-mapped region.
      *
-     * On success, the object takes ownership of "dataMap".
+     * On success, the object takes ownership of "dataMap" and "fd".
      */
-    status_t openChunk(FileMap* dataMap);
+    status_t openChunk(FileMap* dataMap, base::unique_fd fd);
 
     /*
      * Standard Asset interfaces.
@@ -273,11 +281,12 @@ public:
     virtual bool isAllocated(void) const { return mBuf != NULL; }
 
 private:
-    off64_t     mStart;         // absolute file offset of start of chunk
-    off64_t     mLength;        // length of the chunk
-    off64_t     mOffset;        // current local offset, 0 == mStart
-    FILE*       mFp;            // for read/seek
-    char*       mFileName;      // for opening
+    off64_t         mStart;         // absolute file offset of start of chunk
+    off64_t         mLength;        // length of the chunk
+    off64_t         mOffset;        // current local offset, 0 == mStart
+    FILE*           mFp;            // for read/seek
+    char*           mFileName;      // for opening
+    base::unique_fd mFd;            // for opening file descriptors
 
     /*
      * To support getBuffer() we either need to read the entire thing into
diff --git a/libs/androidfw/include/androidfw/LoadedArsc.h b/libs/androidfw/include/androidfw/LoadedArsc.h
index b5d3a1fc6c1f..89ff9f52125d 100644
--- a/libs/androidfw/include/androidfw/LoadedArsc.h
+++ b/libs/androidfw/include/androidfw/LoadedArsc.h
@@ -69,12 +69,24 @@ struct TypeSpec {
   }
 };
 
+// Flags that change the behavior of loaded packages.
+// Keep in sync with f/b/android/content/res/ApkAssets.java
 using package_property_t = uint32_t;
 enum : package_property_t {
-  PROPERTY_DYNAMIC = 1,
-  PROPERTY_LOADER = 2,
-  PROPERTY_OVERLAY = 4,
-  PROPERTY_SYSTEM = 8,
+  // The package contains framework resource values specified by the system.
+  // This allows some functions to filter out this package when computing
+  // what configurations/resources are available.
+  PROPERTY_SYSTEM = 1U << 0U,
+
+  // The package is a shared library or has a package id of 7f and is loaded as a shared library by
+  // force.
+  PROPERTY_DYNAMIC = 1U << 1U,
+
+  // The package has been loaded dynamically using a ResourcesProvider.
+  PROPERTY_LOADER = 1U << 2U,
+
+  // The package is a RRO.
+  PROPERTY_OVERLAY = 1U << 3U,
 };
 
 // TypeSpecPtr points to a block of memory that holds a TypeSpec struct, followed by an array of