Merge changes I5fa70d33,Ibc5ac60a,I2f048fee,I0f801bef into main

* changes:
  [res] Dump resources timings in dumpsys
  [res] Don't create extra asset provider when not needed
  [res] Optimize few functions for dtoh() as a noop
  [res] Optimize isUpToDate() for ApkAssets

17 files changed, 372 insertions, 233 deletions

diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java
index 717a2acb4b4a..1f3e6559a695 100644
--- a/core/java/android/app/ActivityThread.java
+++ b/core/java/android/app/ActivityThread.java
@@ -105,6 +105,7 @@ import android.content.pm.ServiceInfo;
 import android.content.res.AssetManager;
 import android.content.res.CompatibilityInfo;
 import android.content.res.Configuration;
+import android.content.res.ResourceTimer;
 import android.content.res.Resources;
 import android.content.res.ResourcesImpl;
 import android.content.res.loader.ResourcesLoader;
@@ -5253,6 +5254,7 @@ public final class ActivityThread extends ClientTransactionHandler
 
             Resources.dumpHistory(pw, "");
             pw.flush();
+            ResourceTimer.dumpTimers(info.fd.getFileDescriptor(), "-refresh");
             if (info.finishCallback != null) {
                 info.finishCallback.sendResult(null);
             }
diff --git a/core/java/android/content/res/ApkAssets.java b/core/java/android/content/res/ApkAssets.java
index 908999b64961..b938aac811fd 100644
--- a/core/java/android/content/res/ApkAssets.java
+++ b/core/java/android/content/res/ApkAssets.java
@@ -25,6 +25,7 @@ import android.content.res.loader.ResourcesProvider;
 import android.ravenwood.annotation.RavenwoodClassLoadHook;
 import android.ravenwood.annotation.RavenwoodKeepWholeClass;
 import android.text.TextUtils;
+import android.util.Log;
 
 import com.android.internal.annotations.GuardedBy;
 
@@ -50,6 +51,7 @@ import java.util.Objects;
 @RavenwoodKeepWholeClass
 @RavenwoodClassLoadHook(RavenwoodClassLoadHook.LIBANDROID_LOADING_HOOK)
 public final class ApkAssets {
+    private static final boolean DEBUG = false;
 
     /**
      * The apk assets contains framework resource values specified by the system.
@@ -134,6 +136,17 @@ public final class ApkAssets {
     @Nullable
     private final AssetsProvider mAssets;
 
+    @NonNull
+    private String mName;
+
+    private static final int UPTODATE_FALSE = 0;
+    private static final int UPTODATE_TRUE = 1;
+    private static final int UPTODATE_ALWAYS_TRUE = 2;
+
+    // Start with the only value that may change later and would force a native call to
+    // double check it.
+    private int mPreviousUpToDateResult = UPTODATE_TRUE;
+
     /**
      * Creates a new ApkAssets instance from the given path on disk.
      *
@@ -304,7 +317,7 @@ public final class ApkAssets {
 
     private ApkAssets(@FormatType int format, @NonNull String path, @PropertyFlags int flags,
             @Nullable AssetsProvider assets) throws IOException {
-        this(format, flags, assets);
+        this(format, flags, assets, path);
         Objects.requireNonNull(path, "path");
         mNativePtr = nativeLoad(format, path, flags, assets);
         mStringBlock = new StringBlock(nativeGetStringBlock(mNativePtr), true /*useSparse*/);
@@ -313,7 +326,7 @@ public final class ApkAssets {
     private ApkAssets(@FormatType int format, @NonNull FileDescriptor fd,
             @NonNull String friendlyName, @PropertyFlags int flags, @Nullable AssetsProvider assets)
             throws IOException {
-        this(format, flags, assets);
+        this(format, flags, assets, friendlyName);
         Objects.requireNonNull(fd, "fd");
         Objects.requireNonNull(friendlyName, "friendlyName");
         mNativePtr = nativeLoadFd(format, fd, friendlyName, flags, assets);
@@ -323,7 +336,7 @@ public final class ApkAssets {
     private ApkAssets(@FormatType int format, @NonNull FileDescriptor fd,
             @NonNull String friendlyName, long offset, long length, @PropertyFlags int flags,
             @Nullable AssetsProvider assets) throws IOException {
-        this(format, flags, assets);
+        this(format, flags, assets, friendlyName);
         Objects.requireNonNull(fd, "fd");
         Objects.requireNonNull(friendlyName, "friendlyName");
         mNativePtr = nativeLoadFdOffsets(format, fd, friendlyName, offset, length, flags, assets);
@@ -331,16 +344,17 @@ public final class ApkAssets {
     }
 
     private ApkAssets(@PropertyFlags int flags, @Nullable AssetsProvider assets) {
-        this(FORMAT_APK, flags, assets);
+        this(FORMAT_APK, flags, assets, "empty");
         mNativePtr = nativeLoadEmpty(flags, assets);
         mStringBlock = null;
     }
 
     private ApkAssets(@FormatType int format, @PropertyFlags int flags,
-            @Nullable AssetsProvider assets) {
+            @Nullable AssetsProvider assets, @NonNull String name) {
         mFlags = flags;
         mAssets = assets;
         mIsOverlay = format == FORMAT_IDMAP;
+        if (DEBUG) mName = name;
     }
 
     @UnsupportedAppUsage
@@ -421,13 +435,41 @@ public final class ApkAssets {
         }
     }
 
+    private static double intervalMs(long beginNs, long endNs) {
+        return (endNs - beginNs) / 1000000.0;
+    }
+
     /**
      * Returns false if the underlying APK was changed since this ApkAssets was loaded.
      */
     public boolean isUpToDate() {
+        // This function is performance-critical - it's called multiple times on every Resources
+        // object creation, and on few other cache accesses - so it's important to avoid the native
+        // call when we know for sure what it will return (which is the case for both ALWAYS_TRUE
+        // and FALSE).
+        if (mPreviousUpToDateResult != UPTODATE_TRUE) {
+            return mPreviousUpToDateResult == UPTODATE_ALWAYS_TRUE;
+        }
+        final long beforeTs, afterLockTs, afterNativeTs, afterUnlockTs;
+        if (DEBUG) beforeTs = System.nanoTime();
+        final int res;
         synchronized (this) {
-            return nativeIsUpToDate(mNativePtr);
+            if (DEBUG) afterLockTs = System.nanoTime();
+            res = nativeIsUpToDate(mNativePtr);
+            if (DEBUG) afterNativeTs = System.nanoTime();
+        }
+        if (DEBUG) {
+            afterUnlockTs = System.nanoTime();
+            if (afterUnlockTs - beforeTs >= 10L * 1000000) {
+                Log.d("ApkAssets", "isUpToDate(" + mName + ") took "
+                        + intervalMs(beforeTs, afterUnlockTs)
+                        + " ms: " + intervalMs(beforeTs, afterLockTs)
+                        + " / " + intervalMs(afterLockTs, afterNativeTs)
+                        + " / " + intervalMs(afterNativeTs, afterUnlockTs));
+            }
         }
+        mPreviousUpToDateResult = res;
+        return res != UPTODATE_FALSE;
     }
 
     public boolean isSystem() {
@@ -487,7 +529,7 @@ public final class ApkAssets {
     private static native @NonNull String nativeGetAssetPath(long ptr);
     private static native @NonNull String nativeGetDebugName(long ptr);
     private static native long nativeGetStringBlock(long ptr);
-    @CriticalNative private static native boolean nativeIsUpToDate(long ptr);
+    @CriticalNative private static native int nativeIsUpToDate(long ptr);
     private static native long nativeOpenXml(long ptr, @NonNull String fileName) throws IOException;
     private static native @Nullable OverlayableInfo nativeGetOverlayableInfo(long ptr,
             String overlayableName) throws IOException;
diff --git a/core/java/android/content/res/ResourceTimer.java b/core/java/android/content/res/ResourceTimer.java
index d51f64ce8106..2d1bf4d9d296 100644
--- a/core/java/android/content/res/ResourceTimer.java
+++ b/core/java/android/content/res/ResourceTimer.java
@@ -17,13 +17,10 @@
 package android.content.res;
 
 import android.annotation.NonNull;
-import android.annotation.Nullable;
-
 import android.app.AppProtoEnums;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
-import android.os.ParcelFileDescriptor;
 import android.os.Process;
 import android.os.SystemClock;
 import android.text.TextUtils;
@@ -33,6 +30,7 @@ import com.android.internal.annotations.GuardedBy;
 import com.android.internal.util.FastPrintWriter;
 import com.android.internal.util.FrameworkStatsLog;
 
+import java.io.FileDescriptor;
 import java.io.FileOutputStream;
 import java.io.PrintWriter;
 import java.util.Arrays;
@@ -277,38 +275,40 @@ public final class ResourceTimer {
      * Update the metrics information and dump it.
      * @hide
      */
-    public static void dumpTimers(@NonNull ParcelFileDescriptor pfd, @Nullable String[] args) {
-        FileOutputStream fout = new FileOutputStream(pfd.getFileDescriptor());
-        PrintWriter pw = new FastPrintWriter(fout);
-        synchronized (sLock) {
-            if (!sEnabled || (sConfig == null)) {
+    public static void dumpTimers(@NonNull FileDescriptor fd, String... args) {
+        try (PrintWriter pw = new FastPrintWriter(new FileOutputStream(fd))) {
+            pw.println("\nDumping ResourceTimers");
+
+            final boolean enabled;
+            synchronized (sLock) {
+                enabled = sEnabled && sConfig != null;
+            }
+            if (!enabled) {
                 pw.println("  Timers are not enabled in this process");
-                pw.flush();
                 return;
             }
-        }
 
-        // Look for the --refresh switch.  If the switch is present, then sTimers is updated.
-        // Otherwise, the current value of sTimers is displayed.
-        boolean refresh = Arrays.asList(args).contains("-refresh");
-
-        synchronized (sLock) {
-            update(refresh);
-            long runtime = sLastUpdated - sProcessStart;
-            pw.format("  config runtime=%d proc=%s\n", runtime, Process.myProcessName());
-            for (int i = 0; i < sTimers.length; i++) {
-                Timer t = sTimers[i];
-                if (t.count != 0) {
-                    String name = sConfig.timers[i];
-                    pw.format("  stats timer=%s cnt=%d avg=%d min=%d max=%d pval=%s "
-                        + "largest=%s\n",
-                        name, t.count, t.total / t.count, t.mintime, t.maxtime,
-                        packedString(t.percentile),
-                        packedString(t.largest));
+            // Look for the --refresh switch.  If the switch is present, then sTimers is updated.
+            // Otherwise, the current value of sTimers is displayed.
+            boolean refresh = Arrays.asList(args).contains("-refresh");
+
+            synchronized (sLock) {
+                update(refresh);
+                long runtime = sLastUpdated - sProcessStart;
+                pw.format("  config runtime=%d proc=%s\n", runtime, Process.myProcessName());
+                for (int i = 0; i < sTimers.length; i++) {
+                    Timer t = sTimers[i];
+                    if (t.count != 0) {
+                        String name = sConfig.timers[i];
+                        pw.format("  stats timer=%s cnt=%d avg=%d min=%d max=%d pval=%s "
+                                        + "largest=%s\n",
+                                name, t.count, t.total / t.count, t.mintime, t.maxtime,
+                                packedString(t.percentile),
+                                packedString(t.largest));
+                    }
                 }
             }
         }
-        pw.flush();
     }
 
     // Enable (or disabled) the runtime timers.  Note that timers are disabled by default.  This
diff --git a/core/jni/android_content_res_ApkAssets.cpp b/core/jni/android_content_res_ApkAssets.cpp
index 1e7bfe32ba79..e6364a96bd9f 100644
--- a/core/jni/android_content_res_ApkAssets.cpp
+++ b/core/jni/android_content_res_ApkAssets.cpp
@@ -111,9 +111,8 @@ static void DeleteGuardedApkAssets(Guarded<AssetManager2::ApkAssetsPtr>& apk_ass
 class LoaderAssetsProvider : public AssetsProvider {
  public:
   static std::unique_ptr<AssetsProvider> Create(JNIEnv* env, jobject assets_provider) {
-    return (!assets_provider) ? EmptyAssetsProvider::Create()
-                              : std::unique_ptr<AssetsProvider>(new LoaderAssetsProvider(
-                                    env, assets_provider));
+      return std::unique_ptr<AssetsProvider>{
+              assets_provider ? new LoaderAssetsProvider(env, assets_provider) : nullptr};
   }
 
   bool ForEachFile(const std::string& /* root_path */,
@@ -129,8 +128,8 @@ class LoaderAssetsProvider : public AssetsProvider {
     return debug_name_;
   }
 
-  bool IsUpToDate() const override {
-    return true;
+  UpToDate IsUpToDate() const override {
+      return UpToDate::Always;
   }
 
   ~LoaderAssetsProvider() override {
@@ -212,7 +211,7 @@ class LoaderAssetsProvider : public AssetsProvider {
     auto string_result = static_cast<jstring>(env->CallObjectMethod(
         assets_provider_, gAssetsProviderOffsets.toString));
     ScopedUtfChars str(env, string_result);
-    debug_name_ = std::string(str.c_str(), str.size());
+    debug_name_ = std::string(str.c_str());
   }
 
   // The global reference to the AssetsProvider
@@ -243,10 +242,10 @@ static jlong NativeLoad(JNIEnv* env, jclass /*clazz*/, const format_type_t forma
       apk_assets = ApkAssets::LoadOverlay(path.c_str(), property_flags);
       break;
     case FORMAT_ARSC:
-      apk_assets = ApkAssets::LoadTable(AssetsProvider::CreateAssetFromFile(path.c_str()),
-                                        std::move(loader_assets),
-                                        property_flags);
-      break;
+        apk_assets = ApkAssets::LoadTable(AssetsProvider::CreateAssetFromFile(path.c_str()),
+                                          MultiAssetsProvider::Create(std::move(loader_assets)),
+                                          property_flags);
+        break;
     case FORMAT_DIRECTORY: {
       auto assets = MultiAssetsProvider::Create(std::move(loader_assets),
                                                 DirectoryAssetsProvider::Create(path.c_str()));
@@ -316,10 +315,11 @@ static jlong NativeLoadFromFd(JNIEnv* env, jclass /*clazz*/, const format_type_t
         break;
     }
     case FORMAT_ARSC:
-      apk_assets = ApkAssets::LoadTable(
-          AssetsProvider::CreateAssetFromFd(std::move(dup_fd), nullptr /* path */),
-          std::move(loader_assets), property_flags);
-      break;
+        apk_assets = ApkAssets::LoadTable(AssetsProvider::CreateAssetFromFd(std::move(dup_fd),
+                                                                            nullptr /* path */),
+                                          MultiAssetsProvider::Create(std::move(loader_assets)),
+                                          property_flags);
+        break;
     default:
       const std::string error_msg = base::StringPrintf("Unsupported format type %d", format);
       jniThrowException(env, "java/lang/IllegalArgumentException", error_msg.c_str());
@@ -386,12 +386,15 @@ static jlong NativeLoadFromFdOffset(JNIEnv* env, jclass /*clazz*/, const format_
         break;
     }
     case FORMAT_ARSC:
-      apk_assets = ApkAssets::LoadTable(
-          AssetsProvider::CreateAssetFromFd(std::move(dup_fd), nullptr /* path */,
-                                            static_cast<off64_t>(offset),
-                                            static_cast<off64_t>(length)),
-          std::move(loader_assets), property_flags);
-      break;
+        apk_assets =
+                ApkAssets::LoadTable(AssetsProvider::CreateAssetFromFd(std::move(dup_fd),
+                                                                       nullptr /* path */,
+                                                                       static_cast<off64_t>(offset),
+                                                                       static_cast<off64_t>(
+                                                                               length)),
+                                     MultiAssetsProvider::Create(std::move(loader_assets)),
+                                     property_flags);
+        break;
     default:
       const std::string error_msg = base::StringPrintf("Unsupported format type %d", format);
       jniThrowException(env, "java/lang/IllegalArgumentException", error_msg.c_str());
@@ -408,13 +411,16 @@ static jlong NativeLoadFromFdOffset(JNIEnv* env, jclass /*clazz*/, const format_
 }
 
 static jlong NativeLoadEmpty(JNIEnv* env, jclass /*clazz*/, jint flags, jobject assets_provider) {
-  auto apk_assets = ApkAssets::Load(LoaderAssetsProvider::Create(env, assets_provider), flags);
-  if (apk_assets == nullptr) {
-    const std::string error_msg =
-        base::StringPrintf("Failed to load empty assets with provider %p", (void*)assets_provider);
-    jniThrowException(env, "java/io/IOException", error_msg.c_str());
-    return 0;
-  }
+    auto apk_assets = ApkAssets::Load(MultiAssetsProvider::Create(
+                                              LoaderAssetsProvider::Create(env, assets_provider)),
+                                      flags);
+    if (apk_assets == nullptr) {
+        const std::string error_msg =
+                base::StringPrintf("Failed to load empty assets with provider %p",
+                                   (void*)assets_provider);
+        jniThrowException(env, "java/io/IOException", error_msg.c_str());
+        return 0;
+    }
   return CreateGuardedApkAssets(std::move(apk_assets));
 }
 
@@ -443,10 +449,10 @@ static jlong NativeGetStringBlock(JNIEnv* /*env*/, jclass /*clazz*/, jlong ptr)
     return reinterpret_cast<jlong>(apk_assets->GetLoadedArsc()->GetStringPool());
 }
 
-static jboolean NativeIsUpToDate(CRITICAL_JNI_PARAMS_COMMA jlong ptr) {
+static jint NativeIsUpToDate(CRITICAL_JNI_PARAMS_COMMA jlong ptr) {
     auto scoped_apk_assets = ScopedLock(ApkAssetsFromLong(ptr));
     auto apk_assets = scoped_apk_assets->get();
-    return apk_assets->IsUpToDate() ? JNI_TRUE : JNI_FALSE;
+    return (jint)apk_assets->IsUpToDate();
 }
 
 static jlong NativeOpenXml(JNIEnv* env, jclass /*clazz*/, jlong ptr, jstring file_name) {
@@ -558,7 +564,7 @@ static const JNINativeMethod gApkAssetsMethods[] = {
         {"nativeGetDebugName", "(J)Ljava/lang/String;", (void*)NativeGetDebugName},
         {"nativeGetStringBlock", "(J)J", (void*)NativeGetStringBlock},
         // @CriticalNative
-        {"nativeIsUpToDate", "(J)Z", (void*)NativeIsUpToDate},
+        {"nativeIsUpToDate", "(J)I", (void*)NativeIsUpToDate},
         {"nativeOpenXml", "(JLjava/lang/String;)J", (void*)NativeOpenXml},
         {"nativeGetOverlayableInfo", "(JLjava/lang/String;)Landroid/content/om/OverlayableInfo;",
          (void*)NativeGetOverlayableInfo},
diff --git a/libs/androidfw/ApkAssets.cpp b/libs/androidfw/ApkAssets.cpp
index dbb891455ddd..e693fcfd3918 100644
--- a/libs/androidfw/ApkAssets.cpp
+++ b/libs/androidfw/ApkAssets.cpp
@@ -162,10 +162,13 @@ const std::string& ApkAssets::GetDebugName() const {
   return assets_provider_->GetDebugName();
 }
 
-bool ApkAssets::IsUpToDate() const {
+UpToDate ApkAssets::IsUpToDate() const {
   // Loaders are invalidated by the app, not the system, so assume they are up to date.
-  return IsLoader() || ((!loaded_idmap_ || loaded_idmap_->IsUpToDate())
-                        && assets_provider_->IsUpToDate());
+  if (IsLoader()) {
+    return UpToDate::Always;
+  }
+  const auto idmap_res = loaded_idmap_ ? loaded_idmap_->IsUpToDate() : UpToDate::Always;
+  return combine(idmap_res, [this] { return assets_provider_->IsUpToDate(); });
 }
 
 }  // namespace android
diff --git a/libs/androidfw/AssetsProvider.cpp b/libs/androidfw/AssetsProvider.cpp
index 2d3c06506a1f..11b12eb030a6 100644
--- a/libs/androidfw/AssetsProvider.cpp
+++ b/libs/androidfw/AssetsProvider.cpp
@@ -24,9 +24,8 @@
 #include <ziparchive/zip_archive.h>
 
 namespace android {
-namespace {
-constexpr const char* kEmptyDebugString = "<empty>";
-} // namespace
+
+static constexpr std::string_view kEmptyDebugString = "<empty>";
 
 std::unique_ptr<Asset> AssetsProvider::Open(const std::string& path, Asset::AccessMode mode,
                                             bool* file_exists) const {
@@ -86,11 +85,9 @@ void ZipAssetsProvider::ZipCloser::operator()(ZipArchive* a) const {
 }
 
 ZipAssetsProvider::ZipAssetsProvider(ZipArchiveHandle handle, PathOrDebugName&& path,
-                                     package_property_t flags, time_t last_mod_time)
-    : zip_handle_(handle),
-      name_(std::move(path)),
-      flags_(flags),
-      last_mod_time_(last_mod_time) {}
+                                     package_property_t flags, ModDate last_mod_time)
+    : zip_handle_(handle), name_(std::move(path)), flags_(flags), last_mod_time_(last_mod_time) {
+}
 
 std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(std::string path,
                                                              package_property_t flags,
@@ -104,10 +101,10 @@ std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(std::string path,
     return {};
   }
 
-  struct stat sb{.st_mtime = -1};
+  ModDate mod_date = kInvalidModDate;
   // Skip all up-to-date checks if the file won't ever change.
-  if (!isReadonlyFilesystem(path.c_str())) {
-    if ((released_fd < 0 ? stat(path.c_str(), &sb) : fstat(released_fd, &sb)) < 0) {
+  if (isKnownWritablePath(path.c_str()) || !isReadonlyFilesystem(GetFileDescriptor(handle))) {
+    if (mod_date = getFileModDate(GetFileDescriptor(handle)); mod_date == kInvalidModDate) {
       // Stat requires execute permissions on all directories path to the file. If the process does
       // not have execute permissions on this file, allow the zip to be opened but IsUpToDate() will
       // always have to return true.
@@ -116,7 +113,7 @@ std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(std::string path,
   }
 
   return std::unique_ptr<ZipAssetsProvider>(
-      new ZipAssetsProvider(handle, PathOrDebugName::Path(std::move(path)), flags, sb.st_mtime));
+      new ZipAssetsProvider(handle, PathOrDebugName::Path(std::move(path)), flags, mod_date));
 }
 
 std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(base::unique_fd fd,
@@ -137,10 +134,10 @@ std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(base::unique_fd fd,
     return {};
   }
 
-  struct stat sb{.st_mtime = -1};
+  ModDate mod_date = kInvalidModDate;
   // Skip all up-to-date checks if the file won't ever change.
   if (!isReadonlyFilesystem(released_fd)) {
-    if (fstat(released_fd, &sb) < 0) {
+    if (mod_date = getFileModDate(released_fd); mod_date == kInvalidModDate) {
       // Stat requires execute permissions on all directories path to the file. If the process does
       // not have execute permissions on this file, allow the zip to be opened but IsUpToDate() will
       // always have to return true.
@@ -150,7 +147,7 @@ std::unique_ptr<ZipAssetsProvider> ZipAssetsProvider::Create(base::unique_fd fd,
   }
 
   return std::unique_ptr<ZipAssetsProvider>(new ZipAssetsProvider(
-      handle, PathOrDebugName::DebugName(std::move(friendly_name)), flags, sb.st_mtime));
+      handle, PathOrDebugName::DebugName(std::move(friendly_name)), flags, mod_date));
 }
 
 std::unique_ptr<Asset> ZipAssetsProvider::OpenInternal(const std::string& path,
@@ -282,21 +279,16 @@ const std::string& ZipAssetsProvider::GetDebugName() const {
   return name_.GetDebugName();
 }
 
-bool ZipAssetsProvider::IsUpToDate() const {
-  if (last_mod_time_ == -1) {
-    return true;
-  }
-  struct stat sb{};
-  if (fstat(GetFileDescriptor(zip_handle_.get()), &sb) < 0) {
-    // If fstat fails on the zip archive, return true so the zip archive the resource system does
-    // attempt to refresh the ApkAsset.
-    return true;
+UpToDate ZipAssetsProvider::IsUpToDate() const {
+  if (last_mod_time_ == kInvalidModDate) {
+    return UpToDate::Always;
   }
-  return last_mod_time_ == sb.st_mtime;
+  return fromBool(last_mod_time_ == getFileModDate(GetFileDescriptor(zip_handle_.get())));
 }
 
-DirectoryAssetsProvider::DirectoryAssetsProvider(std::string&& path, time_t last_mod_time)
-    : dir_(std::move(path)), last_mod_time_(last_mod_time) {}
+DirectoryAssetsProvider::DirectoryAssetsProvider(std::string&& path, ModDate last_mod_time)
+    : dir_(std::move(path)), last_mod_time_(last_mod_time) {
+}
 
 std::unique_ptr<DirectoryAssetsProvider> DirectoryAssetsProvider::Create(std::string path) {
   struct stat sb;
@@ -317,7 +309,7 @@ std::unique_ptr<DirectoryAssetsProvider> DirectoryAssetsProvider::Create(std::st
 
   const bool isReadonly = isReadonlyFilesystem(path.c_str());
   return std::unique_ptr<DirectoryAssetsProvider>(
-      new DirectoryAssetsProvider(std::move(path), isReadonly ? -1 : sb.st_mtime));
+      new DirectoryAssetsProvider(std::move(path), isReadonly ? kInvalidModDate : getModDate(sb)));
 }
 
 std::unique_ptr<Asset> DirectoryAssetsProvider::OpenInternal(const std::string& path,
@@ -346,17 +338,11 @@ const std::string& DirectoryAssetsProvider::GetDebugName() const {
   return dir_;
 }
 
-bool DirectoryAssetsProvider::IsUpToDate() const {
-  if (last_mod_time_ == -1) {
-    return true;
-  }
-  struct stat sb;
-  if (stat(dir_.c_str(), &sb) < 0) {
-    // If stat fails on the zip archive, return true so the zip archive the resource system does
-    // attempt to refresh the ApkAsset.
-    return true;
+UpToDate DirectoryAssetsProvider::IsUpToDate() const {
+  if (last_mod_time_ == kInvalidModDate) {
+    return UpToDate::Always;
   }
-  return last_mod_time_ == sb.st_mtime;
+  return fromBool(last_mod_time_ == getFileModDate(dir_.c_str()));
 }
 
 MultiAssetsProvider::MultiAssetsProvider(std::unique_ptr<AssetsProvider>&& primary,
@@ -369,8 +355,14 @@ MultiAssetsProvider::MultiAssetsProvider(std::unique_ptr<AssetsProvider>&& prima
 
 std::unique_ptr<AssetsProvider> MultiAssetsProvider::Create(
     std::unique_ptr<AssetsProvider>&& primary, std::unique_ptr<AssetsProvider>&& secondary) {
-  if (primary == nullptr || secondary == nullptr) {
-    return nullptr;
+  if (primary == nullptr && secondary == nullptr) {
+    return EmptyAssetsProvider::Create();
+  }
+  if (!primary) {
+    return secondary;
+  }
+  if (!secondary) {
+    return primary;
   }
   return std::unique_ptr<MultiAssetsProvider>(new MultiAssetsProvider(std::move(primary),
                                                                       std::move(secondary)));
@@ -397,8 +389,8 @@ const std::string& MultiAssetsProvider::GetDebugName() const {
   return debug_name_;
 }
 
-bool MultiAssetsProvider::IsUpToDate() const {
-  return primary_->IsUpToDate() && secondary_->IsUpToDate();
+UpToDate MultiAssetsProvider::IsUpToDate() const {
+  return combine(primary_->IsUpToDate(), [this] { return secondary_->IsUpToDate(); });
 }
 
 EmptyAssetsProvider::EmptyAssetsProvider(std::optional<std::string>&& path) :
@@ -438,12 +430,12 @@ const std::string& EmptyAssetsProvider::GetDebugName() const {
   if (path_.has_value()) {
     return *path_;
   }
-  const static std::string kEmpty = kEmptyDebugString;
+  constexpr static std::string kEmpty{kEmptyDebugString};
   return kEmpty;
 }
 
-bool EmptyAssetsProvider::IsUpToDate() const {
-  return true;
+UpToDate EmptyAssetsProvider::IsUpToDate() const {
+  return UpToDate::Always;
 }
 
 }  // namespace android
diff --git a/libs/androidfw/Idmap.cpp b/libs/androidfw/Idmap.cpp
index 3ecd82b074a1..262e7df185b7 100644
--- a/libs/androidfw/Idmap.cpp
+++ b/libs/androidfw/Idmap.cpp
@@ -22,9 +22,10 @@
 #include "android-base/logging.h"
 #include "android-base/stringprintf.h"
 #include "android-base/utf8.h"
-#include "androidfw/misc.h"
+#include "androidfw/AssetManager.h"
 #include "androidfw/ResourceTypes.h"
 #include "androidfw/Util.h"
+#include "androidfw/misc.h"
 #include "utils/ByteOrder.h"
 #include "utils/Trace.h"
 
@@ -268,11 +269,16 @@ LoadedIdmap::LoadedIdmap(const std::string& idmap_path, const Idmap_header* head
       configurations_(configs),
       overlay_entries_(overlay_entries),
       string_pool_(std::move(string_pool)),
-      idmap_fd_(
-          android::base::utf8::open(idmap_path.c_str(), O_RDONLY | O_CLOEXEC | O_BINARY | O_PATH)),
       overlay_apk_path_(overlay_apk_path),
       target_apk_path_(target_apk_path),
-      idmap_last_mod_time_(getFileModDate(idmap_fd_.get())) {
+      idmap_last_mod_time_(kInvalidModDate) {
+  if (!isReadonlyFilesystem(std::string(overlay_apk_path_).c_str()) ||
+      !(target_apk_path_ == AssetManager::TARGET_APK_PATH ||
+        isReadonlyFilesystem(std::string(target_apk_path_).c_str()))) {
+    idmap_fd_.reset(
+        android::base::utf8::open(idmap_path.c_str(), O_RDONLY | O_CLOEXEC | O_BINARY | O_PATH));
+    idmap_last_mod_time_ = getFileModDate(idmap_fd_);
+  }
 }
 
 std::unique_ptr<LoadedIdmap> LoadedIdmap::Load(StringPiece idmap_path, StringPiece idmap_data) {
@@ -381,8 +387,11 @@ std::unique_ptr<LoadedIdmap> LoadedIdmap::Load(StringPiece idmap_path, StringPie
                       overlay_entries, std::move(idmap_string_pool), *overlay_path, *target_path));
 }
 
-bool LoadedIdmap::IsUpToDate() const {
-  return idmap_last_mod_time_ == getFileModDate(idmap_fd_.get());
+UpToDate LoadedIdmap::IsUpToDate() const {
+  if (idmap_last_mod_time_ == kInvalidModDate) {
+    return UpToDate::Always;
+  }
+  return fromBool(idmap_last_mod_time_ == getFileModDate(idmap_fd_.get()));
 }
 
 }  // namespace android
diff --git a/libs/androidfw/ResourceTypes.cpp b/libs/androidfw/ResourceTypes.cpp
index de9991a8be5e..a8eb062a2ece 100644
--- a/libs/androidfw/ResourceTypes.cpp
+++ b/libs/androidfw/ResourceTypes.cpp
@@ -152,12 +152,11 @@ static void fill9patchOffsets(Res_png_9patch* patch) {
     patch->colorsOffset = patch->yDivsOffset + (patch->numYDivs * sizeof(int32_t));
 }
 
-void Res_value::copyFrom_dtoh(const Res_value& src)
-{
-    size = dtohs(src.size);
-    res0 = src.res0;
-    dataType = src.dataType;
-    data = dtohl(src.data);
+void Res_value::copyFrom_dtoh_slow(const Res_value& src) {
+  size = dtohs(src.size);
+  res0 = src.res0;
+  dataType = src.dataType;
+  data = dtohl(src.data);
 }
 
 void Res_png_9patch::deviceToFile()
@@ -2031,16 +2030,6 @@ status_t ResXMLTree::validateNode(const ResXMLTree_node* node) const
 // --------------------------------------------------------------------
 // --------------------------------------------------------------------
 
-void ResTable_config::copyFromDeviceNoSwap(const ResTable_config& o) {
-    const size_t size = dtohl(o.size);
-    if (size >= sizeof(ResTable_config)) {
-        *this = o;
-    } else {
-        memcpy(this, &o, size);
-        memset(((uint8_t*)this)+size, 0, sizeof(ResTable_config)-size);
-    }
-}
-
 /* static */ size_t unpackLanguageOrRegion(const char in[2], const char base,
         char out[4]) {
   if (in[0] & 0x80) {
@@ -2105,34 +2094,33 @@ size_t ResTable_config::unpackRegion(char region[4]) const {
     return unpackLanguageOrRegion(this->country, '0', region);
 }
 
-
-void ResTable_config::copyFromDtoH(const ResTable_config& o) {
-    copyFromDeviceNoSwap(o);
-    size = sizeof(ResTable_config);
-    mcc = dtohs(mcc);
-    mnc = dtohs(mnc);
-    density = dtohs(density);
-    screenWidth = dtohs(screenWidth);
-    screenHeight = dtohs(screenHeight);
-    sdkVersion = dtohs(sdkVersion);
-    minorVersion = dtohs(minorVersion);
-    smallestScreenWidthDp = dtohs(smallestScreenWidthDp);
-    screenWidthDp = dtohs(screenWidthDp);
-    screenHeightDp = dtohs(screenHeightDp);
-}
-
-void ResTable_config::swapHtoD() {
-    size = htodl(size);
-    mcc = htods(mcc);
-    mnc = htods(mnc);
-    density = htods(density);
-    screenWidth = htods(screenWidth);
-    screenHeight = htods(screenHeight);
-    sdkVersion = htods(sdkVersion);
-    minorVersion = htods(minorVersion);
-    smallestScreenWidthDp = htods(smallestScreenWidthDp);
-    screenWidthDp = htods(screenWidthDp);
-    screenHeightDp = htods(screenHeightDp);
+void ResTable_config::copyFromDtoH_slow(const ResTable_config& o) {
+  copyFromDeviceNoSwap(o);
+  size = sizeof(ResTable_config);
+  mcc = dtohs(mcc);
+  mnc = dtohs(mnc);
+  density = dtohs(density);
+  screenWidth = dtohs(screenWidth);
+  screenHeight = dtohs(screenHeight);
+  sdkVersion = dtohs(sdkVersion);
+  minorVersion = dtohs(minorVersion);
+  smallestScreenWidthDp = dtohs(smallestScreenWidthDp);
+  screenWidthDp = dtohs(screenWidthDp);
+  screenHeightDp = dtohs(screenHeightDp);
+}
+
+void ResTable_config::swapHtoD_slow() {
+  size = htodl(size);
+  mcc = htods(mcc);
+  mnc = htods(mnc);
+  density = htods(density);
+  screenWidth = htods(screenWidth);
+  screenHeight = htods(screenHeight);
+  sdkVersion = htods(sdkVersion);
+  minorVersion = htods(minorVersion);
+  smallestScreenWidthDp = htods(smallestScreenWidthDp);
+  screenWidthDp = htods(screenWidthDp);
+  screenHeightDp = htods(screenHeightDp);
 }
 
 /* static */ inline int compareLocales(const ResTable_config &l, const ResTable_config &r) {
@@ -2145,7 +2133,7 @@ void ResTable_config::swapHtoD() {
     // systems should happen very infrequently (if at all.)
     // The comparison code relies on memcmp low-level optimizations that make it
     // more efficient than strncmp.
-    const char emptyScript[sizeof(l.localeScript)] = {'\0', '\0', '\0', '\0'};
+    static constexpr char emptyScript[sizeof(l.localeScript)] = {'\0', '\0', '\0', '\0'};
     const char *lScript = l.localeScriptWasComputed ? emptyScript : l.localeScript;
     const char *rScript = r.localeScriptWasComputed ? emptyScript : r.localeScript;
 
diff --git a/libs/androidfw/Util.cpp b/libs/androidfw/Util.cpp
index be55fe8b4bb6..86c459fb4647 100644
--- a/libs/androidfw/Util.cpp
+++ b/libs/androidfw/Util.cpp
@@ -32,13 +32,18 @@ namespace android {
 namespace util {
 
 void ReadUtf16StringFromDevice(const uint16_t* src, size_t len, std::string* out) {
-  char buf[5];
-  while (*src && len != 0) {
-    char16_t c = static_cast<char16_t>(dtohs(*src));
-    utf16_to_utf8(&c, 1, buf, sizeof(buf));
-    out->append(buf, strlen(buf));
-    ++src;
-    --len;
+  static constexpr bool kDeviceEndiannessSame = dtohs(0x1001) == 0x1001;
+  if constexpr (kDeviceEndiannessSame) {
+    *out = Utf16ToUtf8({(const char16_t*)src, strnlen16((const char16_t*)src, len)});
+  } else {
+    char buf[5];
+    while (*src && len != 0) {
+      char16_t c = static_cast<char16_t>(dtohs(*src));
+      utf16_to_utf8(&c, 1, buf, sizeof(buf));
+      out->append(buf, strlen(buf));
+      ++src;
+      --len;
+    }
   }
 }
 
@@ -63,8 +68,10 @@ std::string Utf16ToUtf8(StringPiece16 utf16) {
   }
 
   std::string utf8;
-  utf8.resize(utf8_length);
-  utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin(), utf8_length + 1);
+  utf8.resize_and_overwrite(utf8_length, [&utf16](char* data, size_t size) {
+    utf16_to_utf8(utf16.data(), utf16.length(), data, size + 1);
+    return size;
+  });
   return utf8;
 }
 
diff --git a/libs/androidfw/include/androidfw/ApkAssets.h b/libs/androidfw/include/androidfw/ApkAssets.h
index 231808beb718..3f6f4661f2f7 100644
--- a/libs/androidfw/include/androidfw/ApkAssets.h
+++ b/libs/androidfw/include/androidfw/ApkAssets.h
@@ -116,7 +116,7 @@ class ApkAssets : public RefBase {
     return resources_asset_ != nullptr && resources_asset_->isAllocated();
   }
 
-  bool IsUpToDate() const;
+  UpToDate IsUpToDate() const;
 
   // DANGER!
   // This is a destructive method that rips the assets provider out of ApkAssets object.
diff --git a/libs/androidfw/include/androidfw/AssetsProvider.h b/libs/androidfw/include/androidfw/AssetsProvider.h
index d33c325ff369..e3b3ae41f7f4 100644
--- a/libs/androidfw/include/androidfw/AssetsProvider.h
+++ b/libs/androidfw/include/androidfw/AssetsProvider.h
@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-#ifndef ANDROIDFW_ASSETSPROVIDER_H
-#define ANDROIDFW_ASSETSPROVIDER_H
+#pragma once
 
 #include <memory>
 #include <string>
@@ -58,7 +57,7 @@ struct AssetsProvider {
   WARN_UNUSED virtual const std::string& GetDebugName() const = 0;
 
   // Returns whether the interface provides the most recent version of its files.
-  WARN_UNUSED virtual bool IsUpToDate() const = 0;
+  WARN_UNUSED virtual UpToDate IsUpToDate() const = 0;
 
   // Creates an Asset from a file on disk.
   static std::unique_ptr<Asset> CreateAssetFromFile(const std::string& path);
@@ -95,7 +94,7 @@ struct ZipAssetsProvider : public AssetsProvider {
 
   WARN_UNUSED std::optional<std::string_view> GetPath() const override;
   WARN_UNUSED const std::string& GetDebugName() const override;
-  WARN_UNUSED bool IsUpToDate() const override;
+  WARN_UNUSED UpToDate IsUpToDate() const override;
   WARN_UNUSED std::optional<uint32_t> GetCrc(std::string_view path) const;
 
   ~ZipAssetsProvider() override = default;
@@ -106,7 +105,7 @@ struct ZipAssetsProvider : public AssetsProvider {
  private:
   struct PathOrDebugName;
   ZipAssetsProvider(ZipArchive* handle, PathOrDebugName&& path, package_property_t flags,
-                    time_t last_mod_time);
+                    ModDate last_mod_time);
 
   struct PathOrDebugName {
     static PathOrDebugName Path(std::string value) {
@@ -135,7 +134,7 @@ struct ZipAssetsProvider : public AssetsProvider {
   std::unique_ptr<ZipArchive, ZipCloser> zip_handle_;
   PathOrDebugName name_;
   package_property_t flags_;
-  time_t last_mod_time_;
+  ModDate last_mod_time_;
 };
 
 // Supplies assets from a root directory.
@@ -147,7 +146,7 @@ struct DirectoryAssetsProvider : public AssetsProvider {
 
   WARN_UNUSED std::optional<std::string_view> GetPath() const override;
   WARN_UNUSED const std::string& GetDebugName() const override;
-  WARN_UNUSED bool IsUpToDate() const override;
+  WARN_UNUSED UpToDate IsUpToDate() const override;
 
   ~DirectoryAssetsProvider() override = default;
  protected:
@@ -156,23 +155,23 @@ struct DirectoryAssetsProvider : public AssetsProvider {
                                       bool* file_exists) const override;
 
  private:
-  explicit DirectoryAssetsProvider(std::string&& path, time_t last_mod_time);
+  explicit DirectoryAssetsProvider(std::string&& path, ModDate last_mod_time);
   std::string dir_;
-  time_t last_mod_time_;
+  ModDate last_mod_time_;
 };
 
 // Supplies assets from a `primary` asset provider and falls back to supplying assets from the
 // `secondary` asset provider if the asset cannot be found in the `primary`.
 struct MultiAssetsProvider : public AssetsProvider {
   static std::unique_ptr<AssetsProvider> Create(std::unique_ptr<AssetsProvider>&& primary,
-                                                std::unique_ptr<AssetsProvider>&& secondary);
+                                                std::unique_ptr<AssetsProvider>&& secondary = {});
 
   bool ForEachFile(const std::string& root_path,
                    base::function_ref<void(StringPiece, FileType)> f) const override;
 
   WARN_UNUSED std::optional<std::string_view> GetPath() const override;
   WARN_UNUSED const std::string& GetDebugName() const override;
-  WARN_UNUSED bool IsUpToDate() const override;
+  WARN_UNUSED UpToDate IsUpToDate() const override;
 
   ~MultiAssetsProvider() override = default;
  protected:
@@ -199,7 +198,7 @@ struct EmptyAssetsProvider : public AssetsProvider {
 
   WARN_UNUSED std::optional<std::string_view> GetPath() const override;
   WARN_UNUSED const std::string& GetDebugName() const override;
-  WARN_UNUSED bool IsUpToDate() const override;
+  WARN_UNUSED UpToDate IsUpToDate() const override;
 
   ~EmptyAssetsProvider() override = default;
  protected:
@@ -212,5 +211,3 @@ struct EmptyAssetsProvider : public AssetsProvider {
 };
 
 }  // namespace android
-
-#endif /* ANDROIDFW_ASSETSPROVIDER_H */
diff --git a/libs/androidfw/include/androidfw/Idmap.h b/libs/androidfw/include/androidfw/Idmap.h
index ac75eb3bb98c..87f3c9df9a91 100644
--- a/libs/androidfw/include/androidfw/Idmap.h
+++ b/libs/androidfw/include/androidfw/Idmap.h
@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-#ifndef IDMAP_H_
-#define IDMAP_H_
+#pragma once
 
 #include <memory>
 #include <string>
@@ -32,6 +31,31 @@
 
 namespace android {
 
+// An enum that tracks more states than just 'up to date' or 'not' for a resources container:
+// there are several cases where we know for sure that the object can't change and won't get
+// out of date. Reporting those states to the managed layer allows it to stop checking here
+// completely, speeding up the cache lookups by dozens of milliseconds.
+enum class UpToDate : int { False, True, Always };
+
+// Combines two UpToDate values, and only accesses the second one if it matters to the result.
+template <class Getter>
+UpToDate combine(UpToDate first, Getter secondGetter) {
+  switch (first) {
+    case UpToDate::False:
+      return UpToDate::False;
+    case UpToDate::True: {
+      const auto second = secondGetter();
+      return second == UpToDate::False ? UpToDate::False : UpToDate::True;
+    }
+    case UpToDate::Always:
+      return secondGetter();
+  }
+}
+
+inline UpToDate fromBool(bool value) {
+  return value ? UpToDate::True : UpToDate::False;
+}
+
 class LoadedIdmap;
 class IdmapResMap;
 struct Idmap_header;
@@ -196,7 +220,7 @@ class LoadedIdmap {
 
   // Returns whether the idmap file on disk has not been modified since the construction of this
   // LoadedIdmap.
-  bool IsUpToDate() const;
+  UpToDate IsUpToDate() const;
 
  protected:
   // Exposed as protected so that tests can subclass and mock this class out.
@@ -231,5 +255,3 @@ class LoadedIdmap {
 };
 
 }  // namespace android
-
-#endif  // IDMAP_H_
diff --git a/libs/androidfw/include/androidfw/ResourceTypes.h b/libs/androidfw/include/androidfw/ResourceTypes.h
index e330410ed1a0..819fe4b38c87 100644
--- a/libs/androidfw/include/androidfw/ResourceTypes.h
+++ b/libs/androidfw/include/androidfw/ResourceTypes.h
@@ -47,6 +47,8 @@
 
 namespace android {
 
+constexpr const bool kDeviceEndiannessSame = dtohs(0x1001) == 0x1001;
+
 constexpr const uint32_t kIdmapMagic = 0x504D4449u;
 constexpr const uint32_t kIdmapCurrentVersion = 0x0000000Au;
 
@@ -408,7 +410,16 @@ struct Res_value
     typedef uint32_t data_type;
     data_type data;
 
-    void copyFrom_dtoh(const Res_value& src);
+    void copyFrom_dtoh(const Res_value& src) {
+      if constexpr (kDeviceEndiannessSame) {
+        *this = src;
+      } else {
+        copyFrom_dtoh_slow(src);
+      }
+    }
+
+   private:
+    void copyFrom_dtoh_slow(const Res_value& src);
 };
 
 /**
@@ -1254,11 +1265,32 @@ struct ResTable_config
     // Varies in length from 3 to 8 chars. Zero-filled value.
     char localeNumberingSystem[8];
 
-    void copyFromDeviceNoSwap(const ResTable_config& o);
-    
-    void copyFromDtoH(const ResTable_config& o);
-    
-    void swapHtoD();
+    void copyFromDeviceNoSwap(const ResTable_config& o) {
+      const auto o_size = dtohl(o.size);
+      if (o_size >= sizeof(ResTable_config)) [[likely]] {
+        *this = o;
+      } else {
+        memcpy(this, &o, o_size);
+        memset(((uint8_t*)this) + o_size, 0, sizeof(ResTable_config) - o_size);
+      }
+      this->size = sizeof(*this);
+    }
+
+    void copyFromDtoH(const ResTable_config& o) {
+      if constexpr (kDeviceEndiannessSame) {
+        copyFromDeviceNoSwap(o);
+      } else {
+        copyFromDtoH_slow(o);
+      }
+    }
+
+    void swapHtoD() {
+      if constexpr (kDeviceEndiannessSame) {
+        ;  // noop
+      } else {
+        swapHtoD_slow();
+      }
+    }
 
     int compare(const ResTable_config& o) const;
     int compareLogical(const ResTable_config& o) const;
@@ -1384,6 +1416,10 @@ struct ResTable_config
     bool isBetterThanBeforeLocale(const ResTable_config& o, const ResTable_config* requested) const;
 
     String8 toString() const;
+
+   private:
+    void copyFromDtoH_slow(const ResTable_config& o);
+    void swapHtoD_slow();
 };
 
 /**
diff --git a/libs/androidfw/include/androidfw/misc.h b/libs/androidfw/include/androidfw/misc.h
index c9ba8a01a5e9..d8ca64a174a2 100644
--- a/libs/androidfw/include/androidfw/misc.h
+++ b/libs/androidfw/include/androidfw/misc.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <sys/stat.h>
 #include <time.h>
 
 //
@@ -64,10 +65,15 @@ ModDate getFileModDate(const char* fileName);
 /* same, but also returns -1 if the file has already been deleted */
 ModDate getFileModDate(int fd);
 
+// Extract the modification date from the stat structure.
+ModDate getModDate(const struct ::stat& st);
+
 // Check if |path| or |fd| resides on a readonly filesystem.
 bool isReadonlyFilesystem(const char* path);
 bool isReadonlyFilesystem(int fd);
 
+bool isKnownWritablePath(const char* path);
+
 }  // namespace android
 
 // Whoever uses getFileModDate() will need this as well
diff --git a/libs/androidfw/misc.cpp b/libs/androidfw/misc.cpp
index 32f3624a3aee..26eb320805c9 100644
--- a/libs/androidfw/misc.cpp
+++ b/libs/androidfw/misc.cpp
@@ -16,10 +16,10 @@
 
 #define LOG_TAG "misc"
 
-//
-// Miscellaneous utility functions.
-//
-#include <androidfw/misc.h>
+#include "androidfw/misc.h"
+
+#include <errno.h>
+#include <sys/stat.h>
 
 #include "android-base/logging.h"
 
@@ -28,9 +28,7 @@
 #include <sys/vfs.h>
 #endif  // __linux__
 
-#include <errno.h>
-#include <sys/stat.h>
-
+#include <array>
 #include <cstdio>
 #include <cstring>
 #include <tuple>
@@ -40,28 +38,26 @@ namespace android {
 /*
  * Get a file's type.
  */
-FileType getFileType(const char* fileName)
-{
-    struct stat sb;
-
-    if (stat(fileName, &sb) < 0) {
-        if (errno == ENOENT || errno == ENOTDIR)
-            return kFileTypeNonexistent;
-        else {
-            PLOG(ERROR) << "getFileType(): stat(" << fileName << ") failed";
-            return kFileTypeUnknown;
-        }
-    } else {
-        if (S_ISREG(sb.st_mode))
-            return kFileTypeRegular;
-        else if (S_ISDIR(sb.st_mode))
-            return kFileTypeDirectory;
-        else if (S_ISCHR(sb.st_mode))
-            return kFileTypeCharDev;
-        else if (S_ISBLK(sb.st_mode))
-            return kFileTypeBlockDev;
-        else if (S_ISFIFO(sb.st_mode))
-            return kFileTypeFifo;
+FileType getFileType(const char* fileName) {
+  struct stat sb;
+  if (stat(fileName, &sb) < 0) {
+    if (errno == ENOENT || errno == ENOTDIR)
+      return kFileTypeNonexistent;
+    else {
+      PLOG(ERROR) << "getFileType(): stat(" << fileName << ") failed";
+      return kFileTypeUnknown;
+    }
+  } else {
+    if (S_ISREG(sb.st_mode))
+      return kFileTypeRegular;
+    else if (S_ISDIR(sb.st_mode))
+      return kFileTypeDirectory;
+    else if (S_ISCHR(sb.st_mode))
+      return kFileTypeCharDev;
+    else if (S_ISBLK(sb.st_mode))
+      return kFileTypeBlockDev;
+    else if (S_ISFIFO(sb.st_mode))
+      return kFileTypeFifo;
 #if defined(S_ISLNK)
         else if (S_ISLNK(sb.st_mode))
             return kFileTypeSymlink;
@@ -75,7 +71,7 @@ FileType getFileType(const char* fileName)
     }
 }
 
-static ModDate getModDate(const struct stat& st) {
+ModDate getModDate(const struct stat& st) {
 #ifdef _WIN32
   return st.st_mtime;
 #elif defined(__APPLE__)
@@ -113,8 +109,14 @@ bool isReadonlyFilesystem(const char*) {
 bool isReadonlyFilesystem(int) {
     return false;
 }
+bool isKnownWritablePath(const char*) {
+  return false;
+}
 #else   // __linux__
 bool isReadonlyFilesystem(const char* path) {
+  if (isKnownWritablePath(path)) {
+    return false;
+  }
     struct statfs sfs;
     if (::statfs(path, &sfs)) {
         PLOG(ERROR) << "isReadonlyFilesystem(): statfs(" << path << ") failed";
@@ -131,6 +133,13 @@ bool isReadonlyFilesystem(int fd) {
     }
     return (sfs.f_flags & ST_RDONLY) != 0;
 }
+
+bool isKnownWritablePath(const char* path) {
+  // We know that all paths in /data/ are writable.
+  static constexpr char kRwPrefix[] = "/data/";
+  return strncmp(kRwPrefix, path, std::size(kRwPrefix) - 1) == 0;
+}
+
 #endif  // __linux__
 
 }  // namespace android
diff --git a/libs/androidfw/tests/Idmap_test.cpp b/libs/androidfw/tests/Idmap_test.cpp
index cb2e56f5f5e4..22b9e69500d9 100644
--- a/libs/androidfw/tests/Idmap_test.cpp
+++ b/libs/androidfw/tests/Idmap_test.cpp
@@ -218,10 +218,11 @@ TEST_F(IdmapTest, OverlayAssetsIsUpToDate) {
 
   auto apk_assets = ApkAssets::LoadOverlay(temp_file.path);
   ASSERT_NE(nullptr, apk_assets);
-  ASSERT_TRUE(apk_assets->IsUpToDate());
+  ASSERT_TRUE(apk_assets->IsOverlay());
+  ASSERT_EQ(UpToDate::True, apk_assets->IsUpToDate());
 
   unlink(temp_file.path);
-  ASSERT_FALSE(apk_assets->IsUpToDate());
+  ASSERT_EQ(UpToDate::False, apk_assets->IsUpToDate());
 
   const auto sleep_duration =
       std::chrono::nanoseconds(std::max(kModDateResolutionNs, 1'000'000ull));
@@ -230,7 +231,27 @@ TEST_F(IdmapTest, OverlayAssetsIsUpToDate) {
   base::WriteStringToFile("hello", temp_file.path);
   std::this_thread::sleep_for(sleep_duration);
 
-  ASSERT_FALSE(apk_assets->IsUpToDate());
+  ASSERT_EQ(UpToDate::False, apk_assets->IsUpToDate());
+}
+
+TEST(IdmapTestUpToDate, Combine) {
+  ASSERT_EQ(UpToDate::False, combine(UpToDate::False, [] {
+              ADD_FAILURE();  // Shouldn't get called at all.
+              return UpToDate::False;
+            }));
+
+  ASSERT_EQ(UpToDate::False, combine(UpToDate::True, [] { return UpToDate::False; }));
+
+  ASSERT_EQ(UpToDate::True, combine(UpToDate::True, [] { return UpToDate::True; }));
+  ASSERT_EQ(UpToDate::True, combine(UpToDate::True, [] { return UpToDate::Always; }));
+  ASSERT_EQ(UpToDate::True, combine(UpToDate::Always, [] { return UpToDate::True; }));
+
+  ASSERT_EQ(UpToDate::Always, combine(UpToDate::Always, [] { return UpToDate::Always; }));
+}
+
+TEST(IdmapTestUpToDate, FromBool) {
+  ASSERT_EQ(UpToDate::False, fromBool(false));
+  ASSERT_EQ(UpToDate::True, fromBool(true));
 }
 
 }  // namespace
diff --git a/services/core/java/com/android/server/resources/ResourcesManagerShellCommand.java b/services/core/java/com/android/server/resources/ResourcesManagerShellCommand.java
index a75d110e3cd1..17739712d65a 100644
--- a/services/core/java/com/android/server/resources/ResourcesManagerShellCommand.java
+++ b/services/core/java/com/android/server/resources/ResourcesManagerShellCommand.java
@@ -88,6 +88,5 @@ public class ResourcesManagerShellCommand extends ShellCommand {
         out.println("    Print this help text.");
         out.println("  dump <PROCESS>");
         out.println("    Dump the Resources objects in use as well as the history of Resources");
-
     }
 }