diff --git a/libs/libapexutil/Android.bp b/libs/libapexutil/Android.bp
index 5ba3181..4bb78ae 100644
--- a/libs/libapexutil/Android.bp
+++ b/libs/libapexutil/Android.bp
@@ -19,38 +19,46 @@
 }
 
 cc_defaults {
-  name: "libapexutil-deps",
-  static_libs: [
-    "libbase",
-    "liblog",
-    "libprotobuf-cpp-lite",
-    "lib_apex_manifest_proto_lite",
-  ],
+    name: "libapexutil-deps",
+    static_libs: [
+        "libbase",
+        "liblog",
+        "libprotobuf-cpp-lite",
+        "lib_apex_manifest_proto_lite",
+        "libtinyxml2",
+    ],
 }
 
 cc_library_static {
-  name: "libapexutil",
-  defaults: ["libapexutil-deps"],
-  export_include_dirs: ["."],
-  srcs: ["apexutil.cpp"],
-  host_supported: true,
-  apex_available: [
-      "//apex_available:platform",
-      "com.android.runtime",
-  ],
+    name: "libapexutil",
+    defaults: ["libapexutil-deps"],
+    export_include_dirs: ["."],
+    srcs: [
+        "apex_info.cpp",
+        "apex_info_cache.cpp",
+        "apexutil.cpp",
+    ],
+    host_supported: true,
+    recovery_available: true,
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.runtime",
+    ],
+    generated_sources: ["apex-info-list-tinyxml"],
 }
 
 cc_test {
-  name: "libapexutil_tests",
-  srcs: ["*_test.cpp"],
-  defaults: ["libapexutil-deps"],
-  static_libs: [
-    "libapexutil",
-    "libgmock",
-  ],
-  test_suites: [
-    "device-tests",
-    "general-tests",
-  ],
-  host_supported: true,
+    name: "libapexutil_tests",
+    srcs: ["*_test.cpp"],
+    defaults: ["libapexutil-deps"],
+    static_libs: [
+        "libapexutil",
+        "libgmock",
+    ],
+    test_suites: [
+        "device-tests",
+        "general-tests",
+    ],
+    generated_sources: ["apex-info-list-tinyxml"],
+    host_supported: true,
 }
diff --git a/libs/libapexutil/apex_info.cpp b/libs/libapexutil/apex_info.cpp
new file mode 100644
index 0000000..1d0972f
--- /dev/null
+++ b/libs/libapexutil/apex_info.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apex_info.h"
+
+#include <android-base/strings.h>
+
+#include "com_android_apex.h"
+
+namespace android {
+namespace apex {
+namespace util {
+
+using android::base::Error;
+using android::base::Result;
+using android::base::StartsWith;
+using namespace std::literals;
+
+namespace {
+
+bool InSystem(const std::string &original_path) {
+  return StartsWith(original_path, "/system/apex/") ||
+         StartsWith(original_path, "/system_ext/apex/") ||
+         // Guest mode Android may have system APEXes from host via block APEXes
+         StartsWith(original_path, "/dev/block/vd");
+}
+
+bool InProduct(const std::string &original_path) {
+  return StartsWith(original_path, "/product/apex/");
+}
+
+bool InVendor(const std::string &original_path) {
+  return StartsWith(original_path, "/vendor/apex/");
+}
+
+bool InOdm(const std::string &original_path) {
+  return StartsWith(original_path, "/odm/apex/");
+}
+
+Result<ApexType> GetType(const std::string &original_path) {
+  if (InSystem(original_path)) {
+    return ApexType::kSystem;
+  } else if (InProduct(original_path)) {
+    return ApexType::kProduct;
+  } else if (InVendor(original_path)) {
+    return ApexType::kVendor;
+  } else if (InOdm(original_path)) {
+    return ApexType::kOdm;
+  }
+
+  return Error() << "Unknown type based on path " << original_path;
+}
+
+} // namespace
+
+ApexInfo::ApexInfo(const std::string &manifest_name, const std::string &path,
+                   ApexType type)
+    : manifest_name_(manifest_name), path_(path), type_(type) {}
+
+Result<ApexInfoData> GetApexes(const std::string &apex_root,
+                               const std::string &info_list_file) {
+  ApexInfoData info;
+  // To avoid the overhead of parsing the apex data via GetActivePackages
+  // we will form the /apex path directly here and rely on the getIsActive
+  // in the info list.
+
+  auto info_list =
+      ::com::android::apex::readApexInfoList(info_list_file.c_str());
+  if (!info_list.has_value()) {
+    return Error() << "Failed to read apex info list " << info_list_file;
+  }
+  for (const auto &apex_info : info_list->getApexInfo()) {
+
+    // Only include active apexes
+    if (apex_info.hasIsActive() && apex_info.getIsActive()) {
+
+      // Get the pre-installed path of the apex. Normally (i.e. in Android),
+      // failing to find the pre-installed path is an assertion failure
+      // because apexd demands that every apex to have a pre-installed one.
+      // However, when this runs in a VM where apexes are seen as virtio block
+      // devices, the situation is different. If the APEX in the host side is
+      // an updated (or staged) one, the block device representing the APEX on
+      // the VM side doesn't have the pre-installed path because the factory
+      // version of the APEX wasn't exported to the VM. Therefore, we use the
+      // module path as original_path when we are running in a VM which can be
+      // guessed by checking if the path is /dev/block/vdN.
+      std::string path;
+      if (apex_info.hasPreinstalledModulePath()) {
+        path = apex_info.getPreinstalledModulePath();
+      } else if (StartsWith(apex_info.getModulePath(), "/dev/block/vd")) {
+        path = apex_info.getModulePath();
+      } else {
+        return Error() << "Failed to determine original path for apex "
+                       << apex_info.getModuleName() << " at " << info_list_file;
+      }
+      auto type = GetType(path);
+      if (!type.ok()) {
+        return type.error();
+      }
+      info.emplace_back(ApexInfo(apex_info.getModuleName(),
+                                 apex_root + "/"s + apex_info.getModuleName(),
+                                 *type));
+    }
+  }
+  return info;
+}
+
+} // namespace util
+} // namespace apex
+} // namespace android
diff --git a/libs/libapexutil/apex_info.h b/libs/libapexutil/apex_info.h
new file mode 100644
index 0000000..5b4cf6d
--- /dev/null
+++ b/libs/libapexutil/apex_info.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "apexutil.h"
+
+#include <list>
+#include <string>
+
+#include <android-base/result.h>
+
+namespace android {
+namespace apex {
+namespace util {
+
+// APEX types
+enum class ApexType {
+  kSystem,
+  kProduct,
+  kVendor,
+  kOdm,
+};
+
+// ApexInfo -- APEX active information
+class ApexInfo {
+public:
+  ApexInfo(const std::string &manifest_name, const std::string &path,
+           ApexType type);
+
+  // Manifest name from apex-info
+  const std::string &ManifestName() const { return manifest_name_; }
+  // Active mount path
+  const std::string &Path() const { return path_; }
+
+  ApexType Type() const { return type_; }
+
+private:
+  std::string manifest_name_;
+  std::string path_;
+  ApexType type_;
+};
+
+// Get list of active APEXs
+using ApexInfoData = std::vector<ApexInfo>;
+android::base::Result<ApexInfoData>
+GetApexes(const std::string &apex_root = kApexRoot,
+          const std::string &info_file_list = kApexInfoFile);
+
+} // namespace util
+} // namespace apex
+} // namespace android
diff --git a/libs/libapexutil/apex_info_cache.cpp b/libs/libapexutil/apex_info_cache.cpp
new file mode 100644
index 0000000..c2c41d0
--- /dev/null
+++ b/libs/libapexutil/apex_info_cache.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apex_info_cache.h"
+
+namespace android {
+namespace apex {
+namespace util {
+
+using ::android::base::ErrnoError;
+using ::android::base::Error;
+using ::android::base::Result;
+using namespace std::literals;
+
+ApexInfoCache::ApexInfoCache(const std::string &apex_dir,
+                             const std::string &info_file)
+    : dir_(apex_dir), info_file_(info_file) {
+  memset(&mtim_, 0, sizeof(mtim_));
+}
+
+// Read the current modify time of the file, check if any update to stored time
+Result<std::pair<struct timespec, bool>> ApexInfoCache::ModifyTime() const {
+  struct stat cur;
+  auto ret = stat(info_file_.c_str(), &cur);
+  if (ret != 0) {
+    return ErrnoError() << " info file " << info_file_;
+  }
+  const bool is_new_file = (memcmp(&mtim_, &cur.st_mtim, sizeof(mtim_)) != 0);
+  return std::make_pair(cur.st_mtim, is_new_file);
+}
+
+// Check if new data is available
+Result<bool> ApexInfoCache::HasNewData() const {
+  auto ret = ModifyTime();
+  if (!ret.ok()) {
+    return ret.error();
+  }
+  return (*ret).second;
+}
+// Update the stored info held in object along with
+// the current modification timestamp of the info file.
+Result<bool> ApexInfoCache::Update() {
+  auto ret = ModifyTime();
+  if (!ret.ok()) {
+    return ret.error();
+  }
+  if (!(*ret).second) {
+    return false;
+  }
+
+  // Get latest
+  auto latest = GetApexes(dir_, info_file_);
+  if (!latest.ok()) {
+    return Error() << "Failed to read apexes from " << dir_ << " " << info_file_
+                   << " " << latest.error();
+  }
+
+  // stat timestamp could have changed between check and
+  // read this will get picked up on next poll
+  mtim_ = (*ret).first;
+  apex_info_ = std::move(*latest);
+  return true;
+}
+
+} // namespace util
+} // namespace apex
+} // namespace android
diff --git a/libs/libapexutil/apex_info_cache.h b/libs/libapexutil/apex_info_cache.h
new file mode 100644
index 0000000..da6f3b6
--- /dev/null
+++ b/libs/libapexutil/apex_info_cache.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "apex_info.h"
+#include "apexutil.h"
+
+#include <string>
+#include <sys/stat.h>
+
+#include <android-base/result.h>
+
+namespace android {
+namespace apex {
+namespace util {
+
+//
+// Cache current apex information
+//
+class ApexInfoCache {
+public:
+  ApexInfoCache(const std::string &apex_dir = kApexRoot,
+                const std::string &info_file = kApexInfoFile);
+
+  // Check if new data is available
+  android::base::Result<bool> HasNewData() const;
+
+  // Update ApexInfoData data held in the object, if change in
+  // timestamp is detected.  Return true if data has been updated
+  android::base::Result<bool> Update();
+
+  // Get copy of stored information
+  const ApexInfoData &Info() const { return apex_info_; }
+
+protected:
+  // Get the modify time, return true if update detected
+  android::base::Result<std::pair<struct timespec, bool>> ModifyTime() const;
+
+protected:
+  std::string dir_;
+  std::string info_file_;
+  struct timespec mtim_; // last modified time of the file
+  ApexInfoData apex_info_;
+};
+
+} // namespace util
+} // namespace apex
+} // namespace android
diff --git a/libs/libapexutil/apex_info_test.cpp b/libs/libapexutil/apex_info_test.cpp
new file mode 100644
index 0000000..24c3d62
--- /dev/null
+++ b/libs/libapexutil/apex_info_test.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "apex_info.h"
+#include "apex_info_cache.h"
+
+#include <string>
+#include <unistd.h>
+#include <utility>
+
+#include <android-base/file.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "com_android_apex.h"
+
+using namespace std::literals;
+
+using ::android::apex::util::ApexInfoCache;
+using ::android::apex::util::ApexType;
+using ::android::base::WriteStringToFile;
+
+// Create an ApexInfo object based on inputs, writing data to the apex_dir/name
+// directory
+com::android::apex::ApexInfo
+CreateApex(const std::string &name, const std::string &pre_path, int version) {
+  auto version_name = std::to_string(version);
+
+  std::string path = "/apex/" + name;
+  return (com::android::apex::ApexInfo(name, path, pre_path, version,
+                                       version_name, false, true, 0, false));
+}
+
+// Write info file
+void UpdateApexInfoList(const std::string &info_file,
+                        std::vector<com::android::apex::ApexInfo> &apex_infos) {
+  com::android::apex::ApexInfoList apex_info_list(apex_infos);
+  std::stringstream xml;
+  com::android::apex::write(xml, apex_info_list);
+  ASSERT_TRUE(WriteStringToFile(xml.str(), info_file));
+}
+
+void CreateApexData(const std::string &apex_dir, const std::string &info_file,
+                    std::vector<com::android::apex::ApexInfo> &apex_infos) {
+  ASSERT_NE(-1, mkdir(apex_dir.c_str(), 0755) == -1)
+      << "Failed to create apex directory" << apex_dir;
+
+  // Create partition of a given APEX type and add to apex info
+  auto ASSERT_CREATE_PARTITION_APEX = [&apex_dir, &apex_infos](
+                                          std::set<std::string> &names,
+                                          const std::string &partition) {
+    for (const auto &name : names) {
+      apex_infos.emplace_back(
+          CreateApex(name, std::string(partition).append("/").append(name), 1));
+    }
+  };
+
+  // Partition APEXes
+  std::set<std::string> vendor{"com.test_vendor.1", "com.test_vendor.2",
+                               "com.test_vendor.3"};
+  std::set<std::string> system{"com.test_system.1"};
+  std::set<std::string> system_ext{"com.test_system_ext.1"};
+  std::set<std::string> product{"com.test_product.1"};
+  std::set<std::string> odm{"com.test_odm.1"};
+
+  ASSERT_CREATE_PARTITION_APEX(vendor, "/vendor/apex");
+  ASSERT_CREATE_PARTITION_APEX(system, "/system/apex");
+  ASSERT_CREATE_PARTITION_APEX(system_ext, "/system_ext/apex");
+  ASSERT_CREATE_PARTITION_APEX(product, "/product/apex");
+  ASSERT_CREATE_PARTITION_APEX(odm, "/odm/apex");
+
+  // Write the info list
+  UpdateApexInfoList(info_file, apex_infos);
+
+  auto apex = android::apex::util::GetApexes(apex_dir, info_file);
+  auto exp_size = system.size() + system_ext.size() + product.size() +
+                  vendor.size() + odm.size();
+  ASSERT_TRUE(apex.ok());
+  ASSERT_EQ((*apex).size(), exp_size)
+      << "Got apex size " << (*apex).size() << " expected size " << exp_size;
+
+  for (const auto &obj : *apex) {
+    switch (obj.Type()) {
+    case (ApexType::kSystem):
+      ASSERT_EQ(system.count(obj.ManifestName()) +
+                    system_ext.count(obj.ManifestName()),
+                1);
+      system.erase(obj.ManifestName());
+      system_ext.erase(obj.ManifestName());
+      break;
+    case (ApexType::kProduct):
+      ASSERT_EQ(product.count(obj.ManifestName()), 1);
+      product.erase(obj.ManifestName());
+      break;
+    case (ApexType::kVendor):
+      ASSERT_EQ(vendor.count(obj.ManifestName()), 1);
+      vendor.erase(obj.ManifestName());
+      break;
+    case (ApexType::kOdm):
+      ASSERT_EQ(odm.count(obj.ManifestName()), 1);
+      odm.erase(obj.ManifestName());
+      break;
+    }
+  }
+  // Assert all modules identified
+  ASSERT_EQ(system.size(), 0);
+  ASSERT_EQ(system_ext.size(), 0);
+  ASSERT_EQ(product.size(), 0);
+  ASSERT_EQ(vendor.size(), 0);
+  ASSERT_EQ(odm.size(), 0);
+}
+
+TEST(ApexUtil, ApexInfo) {
+  TemporaryDir td;
+  const std::string apex_dir = td.path + "/apex/"s;
+  const std::string info_file = apex_dir + ::android::apex::kApexInfoFileName;
+
+  std::vector<com::android::apex::ApexInfo> apex_infos;
+  CreateApexData(apex_dir, info_file, apex_infos);
+}
+
+TEST(ApexUtil, ApexInfoCache) {
+  // Monitor based on Update()
+  TemporaryDir td;
+  const std::string apex_dir = td.path + "/apex/"s;
+  const std::string info_file = apex_dir + ::android::apex::kApexInfoFileName;
+
+  ASSERT_EQ(mkdir(apex_dir.c_str(), 0755), 0)
+      << "Failed to create apex directory" << apex_dir;
+
+  ApexInfoCache m(apex_dir, info_file);
+  auto ASSERT_NEW_DATA = [&m](bool bExp) {
+    auto ret = m.HasNewData();
+    ASSERT_EQ(ret.ok(), true);
+    ASSERT_EQ(*ret, bExp);
+  };
+  auto ASSERT_UPDATE = [&m](bool bExp) {
+    auto ret = m.Update();
+    ASSERT_EQ(ret.ok(), true);
+    ASSERT_EQ(*ret, bExp);
+  };
+  auto ASSERT_UPDATE_ERROR = [&m]() {
+    auto ret = m.Update();
+    ASSERT_EQ(ret.ok(), false);
+  };
+
+  ASSERT_UPDATE_ERROR();
+
+  // Need to setup actual data to use update
+  std::vector<com::android::apex::ApexInfo> apex_infos;
+  CreateApexData(apex_dir, info_file, apex_infos);
+
+  // validate new data is available
+  ASSERT_NEW_DATA(true);
+  ASSERT_UPDATE(true);
+
+  // No new updates
+  ASSERT_NEW_DATA(false);
+  ASSERT_UPDATE(false);
+
+  // Check existing file update
+  sleep(1); // make sure timestamps change
+  UpdateApexInfoList(info_file, apex_infos);
+  ASSERT_NEW_DATA(true);
+  ASSERT_UPDATE(true);
+
+  // Check that new data can be detected directly with update
+  sleep(1); // make sure timestamps change
+  UpdateApexInfoList(info_file, apex_infos);
+  ASSERT_UPDATE(true);
+  ASSERT_NEW_DATA(false); // new data should be consumed by above call
+}
diff --git a/libs/libapexutil/apexutil.h b/libs/libapexutil/apexutil.h
index f351294..e6c37e4 100644
--- a/libs/libapexutil/apexutil.h
+++ b/libs/libapexutil/apexutil.h
@@ -32,6 +32,8 @@
 GetActivePackages(const std::string &apex_root);
 
 constexpr const char *const kApexRoot = "/apex";
+constexpr const char *const kApexInfoFileName = "apex-info-list.xml";
+constexpr const char *const kApexInfoFile = "/apex/apex-info-list.xml";
 
 } // namespace apex
-} // namespace android
\ No newline at end of file
+} // namespace android