diff --git a/target/product/gsi/Android.bp b/target/product/gsi/Android.bp
index a119832..97b3895 100644
--- a/target/product/gsi/Android.bp
+++ b/target/product/gsi/Android.bp
@@ -137,6 +137,7 @@
         "Dialer",
         "LatinIME",
         "apns-full-conf.xml",
+        "frameworks-base-overlays",
     ],
     multilib: {
         lib64: {
diff --git a/tools/aconfig/aconfig/src/codegen/cpp.rs b/tools/aconfig/aconfig/src/codegen/cpp.rs
index d7d77c5..30e1a89 100644
--- a/tools/aconfig/aconfig/src/codegen/cpp.rs
+++ b/tools/aconfig/aconfig/src/codegen/cpp.rs
@@ -31,7 +31,6 @@
     parsed_flags_iter: I,
     codegen_mode: CodegenMode,
     flag_ids: HashMap<String, u16>,
-    allow_instrumentation: bool,
 ) -> Result<Vec<OutputFile>>
 where
     I: Iterator<Item = ProtoParsedFlag>,
@@ -59,7 +58,6 @@
         is_test_mode: codegen_mode == CodegenMode::Test,
         class_elements,
         container,
-        allow_instrumentation,
     };
 
     let files = [
@@ -104,7 +102,6 @@
     pub is_test_mode: bool,
     pub class_elements: Vec<ClassElement>,
     pub container: String,
-    pub allow_instrumentation: bool,
 }
 
 #[derive(Serialize)]
@@ -451,56 +448,6 @@
 
 "#;
 
-    const EXPORTED_EXPORTED_HEADER_EXPECTED: &str = r#"
-#pragma once
-
-#ifdef __cplusplus
-
-#include <memory>
-
-namespace com::android::aconfig::test {
-
-class flag_provider_interface {
-public:
-    virtual ~flag_provider_interface() = default;
-
-    virtual bool disabled_rw_exported() = 0;
-
-    virtual bool enabled_fixed_ro_exported() = 0;
-
-    virtual bool enabled_ro_exported() = 0;
-};
-
-extern std::unique_ptr<flag_provider_interface> provider_;
-
-inline bool disabled_rw_exported() {
-    return provider_->disabled_rw_exported();
-}
-
-inline bool enabled_fixed_ro_exported() {
-    return provider_->enabled_fixed_ro_exported();
-}
-
-inline bool enabled_ro_exported() {
-    return provider_->enabled_ro_exported();
-}
-
-}
-
-extern "C" {
-#endif // __cplusplus
-
-bool com_android_aconfig_test_disabled_rw_exported();
-
-bool com_android_aconfig_test_enabled_fixed_ro_exported();
-
-bool com_android_aconfig_test_enabled_ro_exported();
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-"#;
-
     const EXPORTED_FORCE_READ_ONLY_HEADER_EXPECTED: &str = r#"
 #pragma once
 
@@ -585,7 +532,13 @@
 
     const PROD_SOURCE_FILE_EXPECTED: &str = r#"
 #include "com_android_aconfig_test.h"
-#include <server_configurable_flags/get_flags.h>
+
+#include <unistd.h>
+#include "aconfig_storage/aconfig_storage_read_api.hpp"
+#include <android/log.h>
+#define LOG_TAG "aconfig_cpp_codegen"
+#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
 #include <vector>
 
 namespace com::android::aconfig::test {
@@ -593,36 +546,116 @@
     class flag_provider : public flag_provider_interface {
         public:
 
+            flag_provider()
+                : cache_(4, -1)
+                , boolean_start_index_()
+                , flag_value_file_(nullptr)
+                , package_exists_in_storage_(true) {
+
+                auto package_map_file = aconfig_storage::get_mapped_file(
+                    "system",
+                    aconfig_storage::StorageFileType::package_map);
+                if (!package_map_file.ok()) {
+                    ALOGE("error: failed to get package map file: %s", package_map_file.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                auto context = aconfig_storage::get_package_read_context(
+                    **package_map_file, "com.android.aconfig.test");
+                if (!context.ok()) {
+                    ALOGE("error: failed to get package read context: %s", context.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                if (!(context->package_exists)) {
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                // cache package boolean flag start index
+                boolean_start_index_ = context->boolean_start_index;
+
+                // unmap package map file and free memory
+                delete *package_map_file;
+
+                auto flag_value_file = aconfig_storage::get_mapped_file(
+                    "system",
+                    aconfig_storage::StorageFileType::flag_val);
+                if (!flag_value_file.ok()) {
+                    ALOGE("error: failed to get flag value file: %s", flag_value_file.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                // cache flag value file
+                flag_value_file_ = std::unique_ptr<aconfig_storage::MappedStorageFile>(
+                    *flag_value_file);
+
+            }
+
+
             virtual bool disabled_ro() override {
                 return false;
             }
 
             virtual bool disabled_rw() override {
                 if (cache_[0] == -1) {
-                    cache_[0] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.disabled_rw",
-                        "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 0);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    }
+
+                    cache_[0] = *value;
                 }
                 return cache_[0];
             }
 
             virtual bool disabled_rw_exported() override {
                 if (cache_[1] == -1) {
-                    cache_[1] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.disabled_rw_exported",
-                        "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 1);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    }
+
+                    cache_[1] = *value;
                 }
                 return cache_[1];
             }
 
             virtual bool disabled_rw_in_other_namespace() override {
                 if (cache_[2] == -1) {
-                    cache_[2] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.other_namespace",
-                        "com.android.aconfig.test.disabled_rw_in_other_namespace",
-                        "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 2);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    }
+
+                    cache_[2] = *value;
                 }
                 return cache_[2];
             }
@@ -645,16 +678,32 @@
 
             virtual bool enabled_rw() override {
                 if (cache_[3] == -1) {
-                    cache_[3] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.enabled_rw",
-                        "true") == "true";
+                    if (!package_exists_in_storage_) {
+                        return true;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 7);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return true;
+                    }
+
+                    cache_[3] = *value;
                 }
                 return cache_[3];
             }
 
     private:
         std::vector<int8_t> cache_ = std::vector<int8_t>(4, -1);
+
+        uint32_t boolean_start_index_;
+
+        std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
+
+        bool package_exists_in_storage_;
     };
 
     std::unique_ptr<flag_provider_interface> provider_ =
@@ -701,7 +750,13 @@
 
     const TEST_SOURCE_FILE_EXPECTED: &str = r#"
 #include "com_android_aconfig_test.h"
-#include <server_configurable_flags/get_flags.h>
+
+#include <unistd.h>
+#include "aconfig_storage/aconfig_storage_read_api.hpp"
+#include <android/log.h>
+#define LOG_TAG "aconfig_cpp_codegen"
+#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
 #include <unordered_map>
 #include <string>
 
@@ -711,10 +766,63 @@
         private:
             std::unordered_map<std::string, bool> overrides_;
 
+            uint32_t boolean_start_index_;
+
+            std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
+
+            bool package_exists_in_storage_;
+
         public:
             flag_provider()
                 : overrides_()
-            {}
+                , boolean_start_index_()
+                , flag_value_file_(nullptr)
+                , package_exists_in_storage_(true) {
+
+                auto package_map_file = aconfig_storage::get_mapped_file(
+                     "system",
+                    aconfig_storage::StorageFileType::package_map);
+
+                if (!package_map_file.ok()) {
+                    ALOGE("error: failed to get package map file: %s", package_map_file.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                auto context = aconfig_storage::get_package_read_context(
+                    **package_map_file, "com.android.aconfig.test");
+
+                if (!context.ok()) {
+                    ALOGE("error: failed to get package read context: %s", context.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                if (!(context->package_exists)) {
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                // cache package boolean flag start index
+                boolean_start_index_ = context->boolean_start_index;
+
+                // unmap package map file and free memory
+                delete *package_map_file;
+
+                auto flag_value_file = aconfig_storage::get_mapped_file(
+                    "system",
+                aconfig_storage::StorageFileType::flag_val);
+                if (!flag_value_file.ok()) {
+                    ALOGE("error: failed to get flag value file: %s", flag_value_file.error().c_str());
+                    package_exists_in_storage_ = false;
+                    return;
+                }
+
+                // cache flag value file
+                flag_value_file_ = std::unique_ptr<aconfig_storage::MappedStorageFile>(
+                *flag_value_file);
+
+            }
 
             virtual bool disabled_ro() override {
                 auto it = overrides_.find("disabled_ro");
@@ -734,10 +842,20 @@
                   if (it != overrides_.end()) {
                       return it->second;
                 } else {
-                  return server_configurable_flags::GetServerConfigurableFlag(
-                      "aconfig_flags.aconfig_test",
-                      "com.android.aconfig.test.disabled_rw",
-                      "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 0);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    } else {
+                        return *value;
+                    }
                 }
             }
 
@@ -750,10 +868,20 @@
                   if (it != overrides_.end()) {
                       return it->second;
                 } else {
-                  return server_configurable_flags::GetServerConfigurableFlag(
-                      "aconfig_flags.aconfig_test",
-                      "com.android.aconfig.test.disabled_rw_exported",
-                      "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 1);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    } else {
+                        return *value;
+                    }
                 }
             }
 
@@ -766,10 +894,20 @@
                   if (it != overrides_.end()) {
                       return it->second;
                 } else {
-                  return server_configurable_flags::GetServerConfigurableFlag(
-                      "aconfig_flags.other_namespace",
-                      "com.android.aconfig.test.disabled_rw_in_other_namespace",
-                      "false") == "true";
+                    if (!package_exists_in_storage_) {
+                        return false;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 2);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return false;
+                    } else {
+                        return *value;
+                    }
                 }
             }
 
@@ -834,10 +972,20 @@
                   if (it != overrides_.end()) {
                       return it->second;
                 } else {
-                  return server_configurable_flags::GetServerConfigurableFlag(
-                      "aconfig_flags.aconfig_test",
-                      "com.android.aconfig.test.enabled_rw",
-                      "true") == "true";
+                    if (!package_exists_in_storage_) {
+                        return true;
+                    }
+
+                    auto value = aconfig_storage::get_boolean_flag_value(
+                        *flag_value_file_,
+                        boolean_start_index_ + 7);
+
+                    if (!value.ok()) {
+                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                        return true;
+                    } else {
+                        return *value;
+                    }
                 }
             }
 
@@ -942,68 +1090,6 @@
 
 "#;
 
-    const EXPORTED_SOURCE_FILE_EXPECTED: &str = r#"
-#include "com_android_aconfig_test.h"
-#include <server_configurable_flags/get_flags.h>
-#include <vector>
-
-namespace com::android::aconfig::test {
-
-    class flag_provider : public flag_provider_interface {
-        public:
-            virtual bool disabled_rw_exported() override {
-                if (cache_[0] == -1) {
-                    cache_[0] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.disabled_rw_exported",
-                        "false") == "true";
-                }
-                return cache_[0];
-            }
-
-            virtual bool enabled_fixed_ro_exported() override {
-                if (cache_[1] == -1) {
-                    cache_[1] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.enabled_fixed_ro_exported",
-                        "false") == "true";
-                }
-                return cache_[1];
-            }
-
-            virtual bool enabled_ro_exported() override {
-                if (cache_[2] == -1) {
-                    cache_[2] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.aconfig_test",
-                        "com.android.aconfig.test.enabled_ro_exported",
-                        "false") == "true";
-                }
-                return cache_[2];
-            }
-
-    private:
-        std::vector<int8_t> cache_ = std::vector<int8_t>(3, -1);
-    };
-
-    std::unique_ptr<flag_provider_interface> provider_ =
-        std::make_unique<flag_provider>();
-}
-
-bool com_android_aconfig_test_disabled_rw_exported() {
-    return com::android::aconfig::test::disabled_rw_exported();
-}
-
-bool com_android_aconfig_test_enabled_fixed_ro_exported() {
-    return com::android::aconfig::test::enabled_fixed_ro_exported();
-}
-
-bool com_android_aconfig_test_enabled_ro_exported() {
-    return com::android::aconfig::test::enabled_ro_exported();
-}
-
-
-"#;
-
     const FORCE_READ_ONLY_SOURCE_FILE_EXPECTED: &str = r#"
 #include "com_android_aconfig_test.h"
 
@@ -1188,7 +1274,6 @@
         mode: CodegenMode,
         expected_header: &str,
         expected_src: &str,
-        allow_instrumentation: bool,
     ) {
         let modified_parsed_flags =
             crate::commands::modify_parsed_flags_based_on_mode(parsed_flags, mode).unwrap();
@@ -1199,7 +1284,6 @@
             modified_parsed_flags.into_iter(),
             mode,
             flag_ids,
-            allow_instrumentation,
         )
         .unwrap();
         let mut generated_files_map = HashMap::new();
@@ -1239,7 +1323,6 @@
             CodegenMode::Production,
             EXPORTED_PROD_HEADER_EXPECTED,
             PROD_SOURCE_FILE_EXPECTED,
-            false,
         );
     }
 
@@ -1251,19 +1334,6 @@
             CodegenMode::Test,
             EXPORTED_TEST_HEADER_EXPECTED,
             TEST_SOURCE_FILE_EXPECTED,
-            false,
-        );
-    }
-
-    #[test]
-    fn test_generate_cpp_code_for_exported() {
-        let parsed_flags = crate::test::parse_test_flags();
-        test_generate_cpp_code(
-            parsed_flags,
-            CodegenMode::Exported,
-            EXPORTED_EXPORTED_HEADER_EXPECTED,
-            EXPORTED_SOURCE_FILE_EXPECTED,
-            false,
         );
     }
 
@@ -1275,7 +1345,6 @@
             CodegenMode::ForceReadOnly,
             EXPORTED_FORCE_READ_ONLY_HEADER_EXPECTED,
             FORCE_READ_ONLY_SOURCE_FILE_EXPECTED,
-            false,
         );
     }
 
@@ -1287,7 +1356,6 @@
             CodegenMode::Production,
             READ_ONLY_EXPORTED_PROD_HEADER_EXPECTED,
             READ_ONLY_PROD_SOURCE_FILE_EXPECTED,
-            false,
         );
     }
 }
diff --git a/tools/aconfig/aconfig/src/codegen/rust.rs b/tools/aconfig/aconfig/src/codegen/rust.rs
index 74da1bc..2ee5f36 100644
--- a/tools/aconfig/aconfig/src/codegen/rust.rs
+++ b/tools/aconfig/aconfig/src/codegen/rust.rs
@@ -31,7 +31,6 @@
     flag_ids: HashMap<String, u16>,
     parsed_flags_iter: I,
     codegen_mode: CodegenMode,
-    allow_instrumentation: bool,
 ) -> Result<OutputFile>
 where
     I: Iterator<Item = ProtoParsedFlag>,
@@ -46,7 +45,6 @@
         template_flags,
         modules: package.split('.').map(|s| s.to_string()).collect::<Vec<_>>(),
         has_readwrite,
-        allow_instrumentation,
         container,
     };
     let mut template = TinyTemplate::new();
@@ -70,7 +68,6 @@
     pub template_flags: Vec<TemplateParsedFlag>,
     pub modules: Vec<String>,
     pub has_readwrite: bool,
-    pub allow_instrumentation: bool,
     pub container: String,
 }
 
@@ -134,146 +131,6 @@
 /// flag provider
 pub struct FlagProvider;
 
-    /// flag value cache for disabled_rw
-    static CACHED_disabled_rw: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.disabled_rw",
-        "false") == "true");
-
-    /// flag value cache for disabled_rw_exported
-    static CACHED_disabled_rw_exported: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.disabled_rw_exported",
-        "false") == "true");
-
-    /// flag value cache for disabled_rw_in_other_namespace
-    static CACHED_disabled_rw_in_other_namespace: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.other_namespace",
-        "com.android.aconfig.test.disabled_rw_in_other_namespace",
-        "false") == "true");
-
-    /// flag value cache for enabled_rw
-    static CACHED_enabled_rw: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.enabled_rw",
-        "true") == "true");
-
-impl FlagProvider {
-    /// query flag disabled_ro
-    pub fn disabled_ro(&self) -> bool {
-        false
-    }
-
-    /// query flag disabled_rw
-    pub fn disabled_rw(&self) -> bool {
-        *CACHED_disabled_rw
-    }
-
-    /// query flag disabled_rw_exported
-    pub fn disabled_rw_exported(&self) -> bool {
-        *CACHED_disabled_rw_exported
-    }
-
-    /// query flag disabled_rw_in_other_namespace
-    pub fn disabled_rw_in_other_namespace(&self) -> bool {
-        *CACHED_disabled_rw_in_other_namespace
-    }
-
-    /// query flag enabled_fixed_ro
-    pub fn enabled_fixed_ro(&self) -> bool {
-        true
-    }
-
-    /// query flag enabled_fixed_ro_exported
-    pub fn enabled_fixed_ro_exported(&self) -> bool {
-        true
-    }
-
-    /// query flag enabled_ro
-    pub fn enabled_ro(&self) -> bool {
-        true
-    }
-
-    /// query flag enabled_ro_exported
-    pub fn enabled_ro_exported(&self) -> bool {
-        true
-    }
-
-    /// query flag enabled_rw
-    pub fn enabled_rw(&self) -> bool {
-        *CACHED_enabled_rw
-    }
-}
-
-/// flag provider
-pub static PROVIDER: FlagProvider = FlagProvider;
-
-/// query flag disabled_ro
-#[inline(always)]
-pub fn disabled_ro() -> bool {
-    false
-}
-
-/// query flag disabled_rw
-#[inline(always)]
-pub fn disabled_rw() -> bool {
-    PROVIDER.disabled_rw()
-}
-
-/// query flag disabled_rw_exported
-#[inline(always)]
-pub fn disabled_rw_exported() -> bool {
-    PROVIDER.disabled_rw_exported()
-}
-
-/// query flag disabled_rw_in_other_namespace
-#[inline(always)]
-pub fn disabled_rw_in_other_namespace() -> bool {
-    PROVIDER.disabled_rw_in_other_namespace()
-}
-
-/// query flag enabled_fixed_ro
-#[inline(always)]
-pub fn enabled_fixed_ro() -> bool {
-    true
-}
-
-/// query flag enabled_fixed_ro_exported
-#[inline(always)]
-pub fn enabled_fixed_ro_exported() -> bool {
-    true
-}
-
-/// query flag enabled_ro
-#[inline(always)]
-pub fn enabled_ro() -> bool {
-    true
-}
-
-/// query flag enabled_ro_exported
-#[inline(always)]
-pub fn enabled_ro_exported() -> bool {
-    true
-}
-
-/// query flag enabled_rw
-#[inline(always)]
-pub fn enabled_rw() -> bool {
-    PROVIDER.enabled_rw()
-}
-"#;
-
-    const PROD_INSTRUMENTED_EXPECTED: &str = r#"
-//! codegenerated rust flag lib
-use aconfig_storage_read_api::{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
-use std::path::Path;
-use std::io::Write;
-use std::sync::LazyLock;
-use log::{log, LevelFilter, Level};
-
-/// flag provider
-pub struct FlagProvider;
-
 static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe {
     get_mapped_storage_file("system", StorageFileType::PackageMap)
     .and_then(|package_map| get_package_read_context(&package_map, "com.android.aconfig.test"))
@@ -557,15 +414,189 @@
 
     const TEST_EXPECTED: &str = r#"
 //! codegenerated rust flag lib
-
+use aconfig_storage_read_api::{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
 use std::collections::BTreeMap;
-use std::sync::Mutex;
+use std::path::Path;
+use std::io::Write;
+use std::sync::{LazyLock, Mutex};
+use log::{log, LevelFilter, Level};
 
 /// flag provider
 pub struct FlagProvider {
     overrides: BTreeMap<&'static str, bool>,
 }
 
+static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe {
+    get_mapped_storage_file("system", StorageFileType::PackageMap)
+    .and_then(|package_map| get_package_read_context(&package_map, "com.android.aconfig.test"))
+    .map(|context| context.map(|c| c.boolean_start_index))
+});
+
+static FLAG_VAL_MAP: LazyLock<Result<Mmap, AconfigStorageError>> = LazyLock::new(|| unsafe {
+    get_mapped_storage_file("system", StorageFileType::FlagVal)
+});
+
+/// flag value cache for disabled_rw
+static CACHED_disabled_rw: LazyLock<bool> = LazyLock::new(|| {
+    // This will be called multiple times. Subsequent calls after the first are noops.
+    logger::init(
+        logger::Config::default()
+            .with_tag_on_device("aconfig_rust_codegen")
+            .with_max_level(LevelFilter::Info));
+
+    let flag_value_result = FLAG_VAL_MAP
+        .as_ref()
+        .map_err(|err| format!("failed to get flag val map: {err}"))
+        .and_then(|flag_val_map| {
+            PACKAGE_OFFSET
+               .as_ref()
+               .map_err(|err| format!("failed to get package read offset: {err}"))
+               .and_then(|package_offset| {
+                   match package_offset {
+                       Some(offset) => {
+                           get_boolean_flag_value(&flag_val_map, offset + 0)
+                               .map_err(|err| format!("failed to get flag: {err}"))
+                       },
+                       None => {
+                           log!(Level::Error, "no context found for package com.android.aconfig.test");
+                           Err(format!("failed to flag package com.android.aconfig.test"))
+                       }
+                    }
+                })
+            });
+
+    match flag_value_result {
+        Ok(flag_value) => {
+            return flag_value;
+        },
+        Err(err) => {
+            log!(Level::Error, "aconfig_rust_codegen: error: {err}");
+            return false;
+        }
+    }
+});
+
+/// flag value cache for disabled_rw_exported
+static CACHED_disabled_rw_exported: LazyLock<bool> = LazyLock::new(|| {
+        // This will be called multiple times. Subsequent calls after the first are noops.
+        logger::init(
+            logger::Config::default()
+                .with_tag_on_device("aconfig_rust_codegen")
+                .with_max_level(LevelFilter::Info));
+
+        let flag_value_result = FLAG_VAL_MAP
+            .as_ref()
+            .map_err(|err| format!("failed to get flag val map: {err}"))
+            .and_then(|flag_val_map| {
+                PACKAGE_OFFSET
+                    .as_ref()
+                    .map_err(|err| format!("failed to get package read offset: {err}"))
+                    .and_then(|package_offset| {
+                        match package_offset {
+                            Some(offset) => {
+                                get_boolean_flag_value(&flag_val_map, offset + 1)
+                                    .map_err(|err| format!("failed to get flag: {err}"))
+                            },
+                            None => {
+                                log!(Level::Error, "no context found for package com.android.aconfig.test");
+                                Err(format!("failed to flag package com.android.aconfig.test"))
+                            }
+                        }
+                    })
+                });
+
+        match flag_value_result {
+            Ok(flag_value) => {
+                 return flag_value;
+            },
+            Err(err) => {
+                log!(Level::Error, "aconfig_rust_codegen: error: {err}");
+                return false;
+            }
+        }
+});
+
+/// flag value cache for disabled_rw_in_other_namespace
+static CACHED_disabled_rw_in_other_namespace: LazyLock<bool> = LazyLock::new(|| {
+        // This will be called multiple times. Subsequent calls after the first are noops.
+        logger::init(
+            logger::Config::default()
+                .with_tag_on_device("aconfig_rust_codegen")
+                .with_max_level(LevelFilter::Info));
+
+        let flag_value_result = FLAG_VAL_MAP
+            .as_ref()
+            .map_err(|err| format!("failed to get flag val map: {err}"))
+            .and_then(|flag_val_map| {
+                PACKAGE_OFFSET
+                    .as_ref()
+                    .map_err(|err| format!("failed to get package read offset: {err}"))
+                    .and_then(|package_offset| {
+                        match package_offset {
+                            Some(offset) => {
+                                get_boolean_flag_value(&flag_val_map, offset + 2)
+                                    .map_err(|err| format!("failed to get flag: {err}"))
+                            },
+                            None => {
+                                log!(Level::Error, "no context found for package com.android.aconfig.test");
+                                Err(format!("failed to flag package com.android.aconfig.test"))
+                            }
+                        }
+                    })
+                });
+
+        match flag_value_result {
+            Ok(flag_value) => {
+                 return flag_value;
+            },
+            Err(err) => {
+                log!(Level::Error, "aconfig_rust_codegen: error: {err}");
+                return false;
+            }
+        }
+});
+
+
+/// flag value cache for enabled_rw
+static CACHED_enabled_rw: LazyLock<bool> = LazyLock::new(|| {
+        // This will be called multiple times. Subsequent calls after the first are noops.
+        logger::init(
+            logger::Config::default()
+                .with_tag_on_device("aconfig_rust_codegen")
+                .with_max_level(LevelFilter::Info));
+
+        let flag_value_result = FLAG_VAL_MAP
+            .as_ref()
+            .map_err(|err| format!("failed to get flag val map: {err}"))
+            .and_then(|flag_val_map| {
+                PACKAGE_OFFSET
+                    .as_ref()
+                    .map_err(|err| format!("failed to get package read offset: {err}"))
+                    .and_then(|package_offset| {
+                        match package_offset {
+                            Some(offset) => {
+                                get_boolean_flag_value(&flag_val_map, offset + 7)
+                                    .map_err(|err| format!("failed to get flag: {err}"))
+                            },
+                            None => {
+                                log!(Level::Error, "no context found for package com.android.aconfig.test");
+                                Err(format!("failed to flag package com.android.aconfig.test"))
+                            }
+                        }
+                    })
+                });
+
+        match flag_value_result {
+            Ok(flag_value) => {
+                 return flag_value;
+            },
+            Err(err) => {
+                log!(Level::Error, "aconfig_rust_codegen: error: {err}");
+                return true;
+            }
+        }
+});
+
 impl FlagProvider {
     /// query flag disabled_ro
     pub fn disabled_ro(&self) -> bool {
@@ -582,10 +613,7 @@
     /// query flag disabled_rw
     pub fn disabled_rw(&self) -> bool {
         self.overrides.get("disabled_rw").copied().unwrap_or(
-            flags_rust::GetServerConfigurableFlag(
-                "aconfig_flags.aconfig_test",
-                "com.android.aconfig.test.disabled_rw",
-                "false") == "true"
+            *CACHED_disabled_rw
         )
     }
 
@@ -597,10 +625,7 @@
     /// query flag disabled_rw_exported
     pub fn disabled_rw_exported(&self) -> bool {
         self.overrides.get("disabled_rw_exported").copied().unwrap_or(
-            flags_rust::GetServerConfigurableFlag(
-                "aconfig_flags.aconfig_test",
-                "com.android.aconfig.test.disabled_rw_exported",
-                "false") == "true"
+            *CACHED_disabled_rw_exported
         )
     }
 
@@ -612,10 +637,7 @@
     /// query flag disabled_rw_in_other_namespace
     pub fn disabled_rw_in_other_namespace(&self) -> bool {
         self.overrides.get("disabled_rw_in_other_namespace").copied().unwrap_or(
-            flags_rust::GetServerConfigurableFlag(
-                "aconfig_flags.other_namespace",
-                "com.android.aconfig.test.disabled_rw_in_other_namespace",
-                "false") == "true"
+            *CACHED_disabled_rw_in_other_namespace
         )
     }
 
@@ -675,10 +697,7 @@
     /// query flag enabled_rw
     pub fn enabled_rw(&self) -> bool {
         self.overrides.get("enabled_rw").copied().unwrap_or(
-            flags_rust::GetServerConfigurableFlag(
-                "aconfig_flags.aconfig_test",
-                "com.android.aconfig.test.enabled_rw",
-                "true") == "true"
+            *CACHED_enabled_rw
         )
     }
 
@@ -812,74 +831,6 @@
 }
 "#;
 
-    const EXPORTED_EXPECTED: &str = r#"
-//! codegenerated rust flag lib
-use aconfig_storage_read_api::{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
-use std::path::Path;
-use std::io::Write;
-use std::sync::LazyLock;
-use log::{log, LevelFilter, Level};
-
-/// flag provider
-pub struct FlagProvider;
-
-    /// flag value cache for disabled_rw_exported
-    static CACHED_disabled_rw_exported: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.disabled_rw_exported",
-        "false") == "true");
-
-    /// flag value cache for enabled_fixed_ro_exported
-    static CACHED_enabled_fixed_ro_exported: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.enabled_fixed_ro_exported",
-        "false") == "true");
-
-    /// flag value cache for enabled_ro_exported
-    static CACHED_enabled_ro_exported: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-        "aconfig_flags.aconfig_test",
-        "com.android.aconfig.test.enabled_ro_exported",
-        "false") == "true");
-
-impl FlagProvider {
-    /// query flag disabled_rw_exported
-    pub fn disabled_rw_exported(&self) -> bool {
-        *CACHED_disabled_rw_exported
-    }
-
-    /// query flag enabled_fixed_ro_exported
-    pub fn enabled_fixed_ro_exported(&self) -> bool {
-        *CACHED_enabled_fixed_ro_exported
-    }
-
-    /// query flag enabled_ro_exported
-    pub fn enabled_ro_exported(&self) -> bool {
-        *CACHED_enabled_ro_exported
-    }
-}
-
-/// flag provider
-pub static PROVIDER: FlagProvider = FlagProvider;
-
-/// query flag disabled_rw_exported
-#[inline(always)]
-pub fn disabled_rw_exported() -> bool {
-    PROVIDER.disabled_rw_exported()
-}
-
-/// query flag enabled_fixed_ro_exported
-#[inline(always)]
-pub fn enabled_fixed_ro_exported() -> bool {
-    PROVIDER.enabled_fixed_ro_exported()
-}
-
-/// query flag enabled_ro_exported
-#[inline(always)]
-pub fn enabled_ro_exported() -> bool {
-    PROVIDER.enabled_ro_exported()
-}
-"#;
-
     const FORCE_READ_ONLY_EXPECTED: &str = r#"
 //! codegenerated rust flag lib
 use aconfig_storage_read_api::{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
@@ -964,7 +915,7 @@
 "#;
     use crate::commands::assign_flag_ids;
 
-    fn test_generate_rust_code(mode: CodegenMode, allow_instrumentation: bool, expected: &str) {
+    fn test_generate_rust_code(mode: CodegenMode, expected: &str) {
         let parsed_flags = crate::test::parse_test_flags();
         let modified_parsed_flags =
             crate::commands::modify_parsed_flags_based_on_mode(parsed_flags, mode).unwrap();
@@ -975,7 +926,6 @@
             flag_ids,
             modified_parsed_flags.into_iter(),
             mode,
-            allow_instrumentation,
         )
         .unwrap();
         assert_eq!("src/lib.rs", format!("{}", generated.path.display()));
@@ -990,26 +940,16 @@
 
     #[test]
     fn test_generate_rust_code_for_prod() {
-        test_generate_rust_code(CodegenMode::Production, false, PROD_EXPECTED);
-    }
-
-    #[test]
-    fn test_generate_rust_code_for_prod_instrumented() {
-        test_generate_rust_code(CodegenMode::Production, true, PROD_INSTRUMENTED_EXPECTED);
+        test_generate_rust_code(CodegenMode::Production, PROD_EXPECTED);
     }
 
     #[test]
     fn test_generate_rust_code_for_test() {
-        test_generate_rust_code(CodegenMode::Test, false, TEST_EXPECTED);
-    }
-
-    #[test]
-    fn test_generate_rust_code_for_exported() {
-        test_generate_rust_code(CodegenMode::Exported, false, EXPORTED_EXPECTED);
+        test_generate_rust_code(CodegenMode::Test, TEST_EXPECTED);
     }
 
     #[test]
     fn test_generate_rust_code_for_force_read_only() {
-        test_generate_rust_code(CodegenMode::ForceReadOnly, false, FORCE_READ_ONLY_EXPECTED);
+        test_generate_rust_code(CodegenMode::ForceReadOnly, FORCE_READ_ONLY_EXPECTED);
     }
 }
diff --git a/tools/aconfig/aconfig/src/commands.rs b/tools/aconfig/aconfig/src/commands.rs
index ea1069e..ab726aa 100644
--- a/tools/aconfig/aconfig/src/commands.rs
+++ b/tools/aconfig/aconfig/src/commands.rs
@@ -242,11 +242,7 @@
     generate_java_code(&package, modified_parsed_flags.into_iter(), config)
 }
 
-pub fn create_cpp_lib(
-    mut input: Input,
-    codegen_mode: CodegenMode,
-    allow_instrumentation: bool,
-) -> Result<Vec<OutputFile>> {
+pub fn create_cpp_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Vec<OutputFile>> {
     // TODO(327420679): Enable export mode for native flag library
     ensure!(
         codegen_mode != CodegenMode::Exported,
@@ -259,20 +255,10 @@
     };
     let package = package.to_string();
     let flag_ids = assign_flag_ids(&package, modified_parsed_flags.iter())?;
-    generate_cpp_code(
-        &package,
-        modified_parsed_flags.into_iter(),
-        codegen_mode,
-        flag_ids,
-        allow_instrumentation,
-    )
+    generate_cpp_code(&package, modified_parsed_flags.into_iter(), codegen_mode, flag_ids)
 }
 
-pub fn create_rust_lib(
-    mut input: Input,
-    codegen_mode: CodegenMode,
-    allow_instrumentation: bool,
-) -> Result<OutputFile> {
+pub fn create_rust_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<OutputFile> {
     // // TODO(327420679): Enable export mode for native flag library
     ensure!(
         codegen_mode != CodegenMode::Exported,
@@ -285,13 +271,7 @@
     };
     let package = package.to_string();
     let flag_ids = assign_flag_ids(&package, modified_parsed_flags.iter())?;
-    generate_rust_code(
-        &package,
-        flag_ids,
-        modified_parsed_flags.into_iter(),
-        codegen_mode,
-        allow_instrumentation,
-    )
+    generate_rust_code(&package, flag_ids, modified_parsed_flags.into_iter(), codegen_mode)
 }
 
 pub fn create_storage(
diff --git a/tools/aconfig/aconfig/src/main.rs b/tools/aconfig/aconfig/src/main.rs
index 14bbcc3..ef3b7ab 100644
--- a/tools/aconfig/aconfig/src/main.rs
+++ b/tools/aconfig/aconfig/src/main.rs
@@ -390,10 +390,8 @@
         Some(("create-cpp-lib", sub_matches)) => {
             let cache = open_single_file(sub_matches, "cache")?;
             let mode = get_required_arg::<CodegenMode>(sub_matches, "mode")?;
-            let allow_instrumentation =
-                get_required_arg::<bool>(sub_matches, "allow-instrumentation")?;
-            let generated_files = commands::create_cpp_lib(cache, *mode, *allow_instrumentation)
-                .context("failed to create cpp lib")?;
+            let generated_files =
+                commands::create_cpp_lib(cache, *mode).context("failed to create cpp lib")?;
             let dir = PathBuf::from(get_required_arg::<String>(sub_matches, "out")?);
             generated_files
                 .iter()
@@ -402,10 +400,8 @@
         Some(("create-rust-lib", sub_matches)) => {
             let cache = open_single_file(sub_matches, "cache")?;
             let mode = get_required_arg::<CodegenMode>(sub_matches, "mode")?;
-            let allow_instrumentation =
-                get_required_arg::<bool>(sub_matches, "allow-instrumentation")?;
-            let generated_file = commands::create_rust_lib(cache, *mode, *allow_instrumentation)
-                .context("failed to create rust lib")?;
+            let generated_file =
+                commands::create_rust_lib(cache, *mode).context("failed to create rust lib")?;
             let dir = PathBuf::from(get_required_arg::<String>(sub_matches, "out")?);
             write_output_file_realtive_to_dir(&dir, &generated_file)?;
         }
diff --git a/tools/aconfig/aconfig/templates/cpp_source_file.template b/tools/aconfig/aconfig/templates/cpp_source_file.template
index dc4e435..36ab774 100644
--- a/tools/aconfig/aconfig/templates/cpp_source_file.template
+++ b/tools/aconfig/aconfig/templates/cpp_source_file.template
@@ -1,6 +1,5 @@
 #include "{header}.h"
 
-{{ if allow_instrumentation }}
 {{ if readwrite- }}
 #include <unistd.h>
 #include "aconfig_storage/aconfig_storage_read_api.hpp"
@@ -8,11 +7,7 @@
 #define LOG_TAG "aconfig_cpp_codegen"
 #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
 {{ -endif }}
-{{ endif }}
 
-{{ if readwrite- }}
-#include <server_configurable_flags/get_flags.h>
-{{ endif }}
 {{ if is_test_mode }}
 #include <unordered_map>
 #include <string>
@@ -29,7 +24,6 @@
     private:
         std::unordered_map<std::string, bool> overrides_;
 
-    {{ if allow_instrumentation- }}
     {{ if readwrite- }}
         uint32_t boolean_start_index_;
 
@@ -37,10 +31,8 @@
 
         bool package_exists_in_storage_;
     {{ -endif }}
-    {{ -endif }}
 
     public:
-    {{ if allow_instrumentation- }}
     {{ if readwrite- }}
         flag_provider()
             : overrides_()
@@ -97,11 +89,6 @@
             : overrides_()
         \{}
     {{ -endif }}
-    {{ -else }}
-        flag_provider()
-            : overrides_()
-        \{}
-    {{ -endif }}
 
     {{ for item in class_elements }}
         virtual bool {item.flag_name}() override \{
@@ -110,7 +97,6 @@
                 return it->second;
             } else \{
                 {{ if item.readwrite- }}
-                {{ if allow_instrumentation- }}
                 if (!package_exists_in_storage_) \{
                     return {item.default_value};
                 }
@@ -126,12 +112,6 @@
                     return *value;
                 }
                 {{ -else }}
-                return server_configurable_flags::GetServerConfigurableFlag(
-                  "aconfig_flags.{item.device_config_namespace}",
-                  "{item.device_config_flag}",
-                  "{item.default_value}") == "true";
-                {{ -endif }}
-                {{ -else }}
                 return {item.default_value};
                 {{ -endif }}
             }
@@ -153,7 +133,6 @@
     public:
 
         {{ if readwrite- }}
-        {{ if allow_instrumentation- }}
         flag_provider()
             : cache_({readwrite_count}, -1)
             , boolean_start_index_()
@@ -203,13 +182,11 @@
 
         }
         {{ -endif }}
-        {{ -endif }}
 
         {{ -for item in class_elements }}
         virtual bool {item.flag_name}() override \{
             {{ -if item.readwrite }}
             if (cache_[{item.readwrite_idx}] == -1) \{
-            {{ if allow_instrumentation- }}
                 if (!package_exists_in_storage_) \{
                     return {item.default_value};
                 }
@@ -224,12 +201,6 @@
                 }
 
                 cache_[{item.readwrite_idx}] = *value;
-            {{ -else- }}
-                cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
-                    "aconfig_flags.{item.device_config_namespace}",
-                    "{item.device_config_flag}",
-                    "{item.default_value}") == "true";
-            {{ -endif }}
             }
             return cache_[{item.readwrite_idx}];
             {{ -else }}
@@ -245,14 +216,13 @@
     {{ if readwrite- }}
     private:
         std::vector<int8_t> cache_ = std::vector<int8_t>({readwrite_count}, -1);
-    {{ if allow_instrumentation- }}
+
         uint32_t boolean_start_index_;
 
         std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
 
         bool package_exists_in_storage_;
     {{ -endif }}
-    {{ -endif }}
 
     };
 
diff --git a/tools/aconfig/aconfig/templates/rust.template b/tools/aconfig/aconfig/templates/rust.template
index e9e1032..56323e2 100644
--- a/tools/aconfig/aconfig/templates/rust.template
+++ b/tools/aconfig/aconfig/templates/rust.template
@@ -9,7 +9,6 @@
 pub struct FlagProvider;
 
 {{ if has_readwrite- }}
-{{ if allow_instrumentation }}
 static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe \{
     get_mapped_storage_file("{container}", StorageFileType::PackageMap)
     .and_then(|package_map| get_package_read_context(&package_map, "{package}"))
@@ -19,12 +18,10 @@
 static FLAG_VAL_MAP: LazyLock<Result<Mmap, AconfigStorageError>> = LazyLock::new(|| unsafe \{
     get_mapped_storage_file("{container}", StorageFileType::FlagVal)
 });
-{{ -endif }}
 {{ -for flag in template_flags }}
 
 {{ -if flag.readwrite }}
 /// flag value cache for {flag.name}
-{{ if allow_instrumentation }}
 static CACHED_{flag.name}: LazyLock<bool> = LazyLock::new(|| \{
 
     // This will be called multiple times. Subsequent calls after the first are noops.
@@ -65,12 +62,6 @@
     }
 
 });
-{{ else }}
-static CACHED_{flag.name}: LazyLock<bool> = LazyLock::new(|| flags_rust::GetServerConfigurableFlag(
-    "aconfig_flags.{flag.device_config_namespace}",
-    "{flag.device_config_flag}",
-    "{flag.default_value}") == "true");
-{{ endif }}
 {{ -endif }}
 {{ -endfor }}
 {{ -endif }}
diff --git a/tools/aconfig/aconfig/templates/rust_test.template b/tools/aconfig/aconfig/templates/rust_test.template
index d01f40a..139a5ec 100644
--- a/tools/aconfig/aconfig/templates/rust_test.template
+++ b/tools/aconfig/aconfig/templates/rust_test.template
@@ -1,23 +1,81 @@
 //! codegenerated rust flag lib
-
+use aconfig_storage_read_api::\{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
 use std::collections::BTreeMap;
-use std::sync::Mutex;
+use std::path::Path;
+use std::io::Write;
+use std::sync::\{LazyLock, Mutex};
+use log::\{log, LevelFilter, Level};
 
 /// flag provider
 pub struct FlagProvider \{
     overrides: BTreeMap<&'static str, bool>,
 }
 
+{{ if has_readwrite- }}
+static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe \{
+    get_mapped_storage_file("{container}", StorageFileType::PackageMap)
+    .and_then(|package_map| get_package_read_context(&package_map, "{package}"))
+    .map(|context| context.map(|c| c.boolean_start_index))
+});
+
+static FLAG_VAL_MAP: LazyLock<Result<Mmap, AconfigStorageError>> = LazyLock::new(|| unsafe \{
+    get_mapped_storage_file("{container}", StorageFileType::FlagVal)
+});
+
+{{ -for flag in template_flags }}
+{{ -if flag.readwrite }}
+/// flag value cache for {flag.name}
+static CACHED_{flag.name}: LazyLock<bool> = LazyLock::new(|| \{
+
+    // This will be called multiple times. Subsequent calls after the first are noops.
+    logger::init(
+        logger::Config::default()
+            .with_tag_on_device("aconfig_rust_codegen")
+            .with_max_level(LevelFilter::Info));
+
+    let flag_value_result = FLAG_VAL_MAP
+        .as_ref()
+        .map_err(|err| format!("failed to get flag val map: \{err}"))
+        .and_then(|flag_val_map| \{
+            PACKAGE_OFFSET
+                .as_ref()
+                .map_err(|err| format!("failed to get package read offset: \{err}"))
+                .and_then(|package_offset| \{
+                    match package_offset \{
+                        Some(offset) => \{
+                            get_boolean_flag_value(&flag_val_map, offset + {flag.flag_offset})
+                                .map_err(|err| format!("failed to get flag: \{err}"))
+                        },
+                        None => \{
+                            log!(Level::Error, "no context found for package {package}");
+                            Err(format!("failed to flag package {package}"))
+                        }
+                    }
+                })
+            });
+
+    match flag_value_result \{
+        Ok(flag_value) => \{
+            return flag_value;
+        },
+        Err(err) => \{
+            log!(Level::Error, "aconfig_rust_codegen: error: \{err}");
+            return {flag.default_value};
+        }
+    }
+
+});
+{{ -endif }}
+{{ -endfor }}
+{{ -endif }}
+
 impl FlagProvider \{
 {{ for flag in template_flags }}
     /// query flag {flag.name}
     pub fn {flag.name}(&self) -> bool \{
         self.overrides.get("{flag.name}").copied().unwrap_or(
         {{ if flag.readwrite -}}
-          flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.{flag.device_config_namespace}",
-            "{flag.device_config_flag}",
-            "{flag.default_value}") == "true"
+           *CACHED_{flag.name}
         {{ -else- }}
            {flag.default_value}
         {{ -endif }}
diff --git a/tools/ide_query/ide_query.go b/tools/ide_query/ide_query.go
index c7cf5ed..6caa29c 100644
--- a/tools/ide_query/ide_query.go
+++ b/tools/ide_query/ide_query.go
@@ -116,8 +116,8 @@
 
 	var targets []string
 	javaTargetsByFile := findJavaModules(javaFiles, javaModules)
-	for _, t := range javaTargetsByFile {
-		targets = append(targets, t)
+	for _, target := range javaTargetsByFile {
+		targets = append(targets, javaModules[target].Jars...)
 	}
 
 	ccTargets, err := getCCTargets(ctx, env, ccFiles)
@@ -306,6 +306,10 @@
 		}
 
 		module := modules[name]
+		if len(module.Jars) == 0 {
+			continue
+		}
+
 		for i, p := range paths {
 			if slices.Contains(module.Srcs, p) {
 				ret[p] = name
@@ -317,6 +321,7 @@
 			break
 		}
 	}
+
 	return ret
 }
 
diff --git a/tools/releasetools/sign_target_files_apks.py b/tools/releasetools/sign_target_files_apks.py
index 2378539..f1855a5 100755
--- a/tools/releasetools/sign_target_files_apks.py
+++ b/tools/releasetools/sign_target_files_apks.py
@@ -378,6 +378,37 @@
   return keys_info
 
 
+def GetMicrodroidVbmetaKey(virt_apex_path, avbtool_path):
+  """Extracts the AVB public key from microdroid_vbmeta.img within a virt apex.
+
+  Args:
+    virt_apex_path: The path to the com.android.virt.apex file.
+    avbtool_path: The path to the avbtool executable.
+
+  Returns:
+    The AVB public key (bytes).
+  """
+  # Creates an ApexApkSigner to extract microdroid_vbmeta.img.
+  # No need to set key_passwords/codename_to_api_level_map since
+  # we won't do signing here.
+  apex_signer = apex_utils.ApexApkSigner(
+      virt_apex_path,
+      None,  # key_passwords
+      None)  # codename_to_api_level_map
+  payload_dir = apex_signer.ExtractApexPayload(virt_apex_path)
+  microdroid_vbmeta_image = os.path.join(
+      payload_dir, 'etc', 'fs', 'microdroid_vbmeta.img')
+
+  # Extracts the avb public key from microdroid_vbmeta.img.
+  with tempfile.NamedTemporaryFile() as microdroid_pubkey:
+    common.RunAndCheckOutput([
+        avbtool_path, 'info_image',
+        '--image', microdroid_vbmeta_image,
+        '--output_pubkey', microdroid_pubkey.name])
+    with open(microdroid_pubkey.name, 'rb') as f:
+      return f.read()
+
+
 def GetApkFileInfo(filename, compressed_extension, skipped_prefixes):
   """Returns the APK info based on the given filename.
 
@@ -879,9 +910,8 @@
 
         # b/384813199: handles the pre-signed com.android.virt.apex in GSI.
         if payload_key == 'PRESIGNED':
-          with input_tf_zip.open(virt_apex_path) as apex_fp:
-            with zipfile.ZipFile(apex_fp) as apex_zip:
-              new_pubkey = apex_zip.read('apex_pubkey')
+          new_pubkey = GetMicrodroidVbmetaKey(virt_apex_path,
+                                              misc_info['avb_avbtool'])
         else:
           new_pubkey_path = common.ExtractAvbPublicKey(
               misc_info['avb_avbtool'], payload_key)