VintfObject::GetFwkMatrix combine matrices at runtime am: d52bf3e64c am: f1166a6a17

am: 85b1bde302

Change-Id: If17c173ce5d31ca63e6f22b42a57dbd682b749fe

7 files changed, 198 insertions, 0 deletions

diff --git a/VintfObject.cpp b/VintfObject.cpp
index 8dd08ef..24694cd 100644
--- a/VintfObject.cpp
+++ b/VintfObject.cpp
@@ -20,6 +20,8 @@
 #include "parse_xml.h"
 #include "utils.h"
 
+#include <dirent.h>
+
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -30,6 +32,8 @@
 
 #include <android-base/logging.h>
 
+#define FRAMEWORK_MATRIX_DIR "/system/etc/vintf/"
+
 using std::placeholders::_1;
 using std::placeholders::_2;
 
@@ -119,11 +123,130 @@ std::shared_ptr<const CompatibilityMatrix> VintfObject::GetDeviceCompatibilityMa
 // static
 std::shared_ptr<const CompatibilityMatrix> VintfObject::GetFrameworkCompatibilityMatrix(bool skipCache) {
     static LockedSharedPtr<CompatibilityMatrix> gFrameworkMatrix;
+    static LockedSharedPtr<CompatibilityMatrix> gCombinedFrameworkMatrix;
+    static std::mutex gFrameworkCompatibilityMatrixMutex;
+
+    // To avoid deadlock, get device manifest before any locks.
+    auto deviceManifest = GetDeviceHalManifest();
+
+    std::unique_lock<std::mutex> _lock(gFrameworkCompatibilityMatrixMutex);
+
+    auto combined =
+        Get(&gCombinedFrameworkMatrix, skipCache,
+            std::bind(&VintfObject::GetCombinedFrameworkMatrix, deviceManifest, _1, _2));
+    if (combined != nullptr) {
+        return combined;
+    }
+
     return Get(&gFrameworkMatrix, skipCache,
                std::bind(&CompatibilityMatrix::fetchAllInformation, _1,
                          "/system/compatibility_matrix.xml", _2));
 }
 
+status_t VintfObject::GetCombinedFrameworkMatrix(
+    const std::shared_ptr<const HalManifest>& deviceManifest, CompatibilityMatrix* out,
+    std::string* error) {
+    auto matrixFragments = GetAllFrameworkMatrixLevels(error);
+    if (matrixFragments.empty()) {
+        return NAME_NOT_FOUND;
+    }
+
+    Level deviceLevel = Level::UNSPECIFIED;
+
+    if (deviceManifest != nullptr) {
+        deviceLevel = deviceManifest->level();
+    }
+
+    // TODO(b/70628538): Do not infer from Shipping API level.
+#ifdef LIBVINTF_TARGET
+    if (deviceLevel == Level::UNSPECIFIED) {
+        auto shippingApi =
+            android::base::GetUintProperty<uint64_t>("ro.product.first_api_level", 0u);
+        if (shippingApi != 0u) {
+            deviceLevel = details::convertFromApiLevel(shippingApi);
+        }
+    }
+#endif
+
+    if (deviceLevel == Level::UNSPECIFIED) {
+        // Cannot infer FCM version. Combine all matrices by assuming
+        // Shipping FCM Version == min(all supported FCM Versions in the framework)
+        for (auto&& pair : matrixFragments) {
+            Level fragmentLevel = pair.object.level();
+            if (fragmentLevel != Level::UNSPECIFIED && deviceLevel > fragmentLevel) {
+                deviceLevel = fragmentLevel;
+            }
+        }
+    }
+
+    if (deviceLevel == Level::UNSPECIFIED) {
+        // None of the fragments specify any FCM version. Should never happen except
+        // for inconsistent builds.
+        if (error) {
+            *error = "No framework compatibility matrix files under " FRAMEWORK_MATRIX_DIR
+                     " declare FCM version.";
+        }
+        return NAME_NOT_FOUND;
+    }
+
+    CompatibilityMatrix* combined =
+        CompatibilityMatrix::combine(deviceLevel, &matrixFragments, error);
+    if (combined == nullptr) {
+        return BAD_VALUE;
+    }
+    *out = std::move(*combined);
+    return OK;
+}
+
+std::vector<Named<CompatibilityMatrix>> VintfObject::GetAllFrameworkMatrixLevels(
+    std::string* error) {
+    std::vector<std::string> fileNames;
+    std::vector<Named<CompatibilityMatrix>> results;
+
+    if (details::gFetcher->listFiles(FRAMEWORK_MATRIX_DIR, &fileNames, error) != OK) {
+        return {};
+    }
+    for (const std::string& fileName : fileNames) {
+        std::string path = FRAMEWORK_MATRIX_DIR + fileName;
+
+        std::string content;
+        std::string fetchError;
+        status_t status = details::gFetcher->fetch(path, content, &fetchError);
+        if (status != OK) {
+            if (error) {
+                *error += "Ignore file " + path + ": " + fetchError + "\n";
+            }
+            continue;
+        }
+
+        auto it = results.emplace(results.end());
+        if (!gCompatibilityMatrixConverter(&it->object, content)) {
+            if (error) {
+                // TODO(b/71874788): do not use lastError() because it is not thread-safe.
+                *error +=
+                    "Ignore file " + path + ": " + gCompatibilityMatrixConverter.lastError() + "\n";
+            }
+            results.erase(it);
+            continue;
+        }
+    }
+
+    if (results.empty()) {
+        if (error) {
+            *error = "No framework matrices under " FRAMEWORK_MATRIX_DIR
+                     " can be fetched or parsed.\n" +
+                     *error;
+        }
+    } else {
+        if (error && !error->empty()) {
+            LOG(WARNING) << *error;
+            *error = "";
+        }
+    }
+
+    return results;
+}
+
 // static
 std::shared_ptr<const RuntimeInfo> VintfObject::GetRuntimeInfo(bool skipCache,
                                                                RuntimeInfo::FetchFlags flags) {
diff --git a/include/vintf/CompatibilityMatrix.h b/include/vintf/CompatibilityMatrix.h
index e3432a0..b7a5541 100644
--- a/include/vintf/CompatibilityMatrix.h
+++ b/include/vintf/CompatibilityMatrix.h
@@ -82,6 +82,7 @@ struct CompatibilityMatrix : public HalGroup<MatrixHal>, public XmlFileGroup<Mat
     // - If level() == deviceLevel, all HAL versions and XML files are added as is
     //   (optionality is kept)
     // - If level() > deviceLevel, all HAL versions and XML files are added as optional.
+    // Return a pointer into one of the elements in "matrices".
     static CompatibilityMatrix* combine(Level deviceLevel,
                                         std::vector<Named<CompatibilityMatrix>>* matrices,
                                         std::string* error);
diff --git a/include/vintf/VintfObject.h b/include/vintf/VintfObject.h
index 5593da5..80df9ea 100644
--- a/include/vintf/VintfObject.h
+++ b/include/vintf/VintfObject.h
@@ -22,6 +22,7 @@
 #include "CompatibilityMatrix.h"
 #include "DisabledChecks.h"
 #include "HalManifest.h"
+#include "Named.h"
 #include "RuntimeInfo.h"
 
 namespace android {
@@ -110,6 +111,13 @@ public:
     static int32_t CheckCompatibility(const std::vector<std::string>& packageInfo,
                                       std::string* error = nullptr,
                                       DisabledChecks disabledChecks = ENABLE_ALL_CHECKS);
+
+   private:
+    static status_t GetCombinedFrameworkMatrix(
+        const std::shared_ptr<const HalManifest>& deviceManifest, CompatibilityMatrix* out,
+        std::string* error = nullptr);
+    static std::vector<Named<CompatibilityMatrix>> GetAllFrameworkMatrixLevels(
+        std::string* error = nullptr);
 };
 
 enum : int32_t {
diff --git a/test/Android.bp b/test/Android.bp
index 607d452..540298a 100644
--- a/test/Android.bp
+++ b/test/Android.bp
@@ -68,6 +68,8 @@ cc_test {
     cflags: [
         "-O0",
         "-g",
+        // Unexpected logging of string pointer warning from gmock
+        "-Wno-user-defined-warnings"
     ],
     target: {
         android: {
diff --git a/test/utils-fake.h b/test/utils-fake.h
index 7d7caf2..e2b2706 100644
--- a/test/utils-fake.h
+++ b/test/utils-fake.h
@@ -34,9 +34,14 @@ class MockFileFetcher : public FileFetcher {
         ON_CALL(*this, fetch(_, _)).WillByDefault(Invoke([this](const auto& path, auto& fetched) {
             return real_.fetchInternal(path, fetched, nullptr);
         }));
+        ON_CALL(*this, listFiles(_, _, _))
+            .WillByDefault(
+                Invoke([this](const std::string& path, std::vector<std::string>* out,
+                              std::string* error) { return real_.listFiles(path, out, error); }));
     }
 
     MOCK_METHOD2(fetch, status_t(const std::string& path, std::string& fetched));
+    MOCK_METHOD3(listFiles, status_t(const std::string&, std::vector<std::string>*, std::string*));
 
     status_t fetch(const std::string& path, std::string& fetched, std::string*) override final {
         return fetch(path, fetched);
diff --git a/test/vintf_object_tests.cpp b/test/vintf_object_tests.cpp
index 61eb4df..2dc2d8a 100644
--- a/test/vintf_object_tests.cpp
+++ b/test/vintf_object_tests.cpp
@@ -204,6 +204,9 @@ void setupMockFetcher(const std::string& vendorManifestXml, const std::string& s
             fetched = systemMatrixXml;
             return 0;
         }));
+    // Don't list /system/etc/vintf unless otherwise specified.
+    ON_CALL(*fetcher, listFiles(StrEq("/system/etc/vintf/"), _, _))
+        .WillByDefault(Return(::android::OK));
 }
 
 static MockPartitionMounter &mounter() {
@@ -521,6 +524,41 @@ TEST_F(VintfObjectRuntimeInfoTest, GetRuntimeInfo) {
     VintfObject::GetRuntimeInfo(false /* skipCache */, RuntimeInfo::FetchFlag::ALL);
 }
 
+// Test fixture that provides incompatible metadata from the mock device.
+class VintfObjectTest : public testing::Test {
+   protected:
+    virtual void SetUp() {}
+    virtual void TearDown() {
+        Mock::VerifyAndClear(&fetcher());
+        Mock::VerifyAndClear(&mounter());
+    }
+};
+
+// Test framework compatibility matrix is combined at runtime
+TEST_F(VintfObjectTest, FrameworkCompatibilityMatrixCombine) {
+    EXPECT_CALL(fetcher(), listFiles(StrEq("/system/etc/vintf/"), _, _))
+        .WillOnce(Invoke([](const auto&, auto* out, auto*) {
+            *out = {
+                "compatibility_matrix.1.xml",
+                "compatibility_matrix.empty.xml",
+            };
+            return ::android::OK;
+        }));
+    EXPECT_CALL(fetcher(), fetch(StrEq("/system/etc/vintf/compatibility_matrix.1.xml"), _))
+        .WillOnce(Invoke([](const auto&, auto& out) {
+            out = "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\"/>";
+            return ::android::OK;
+        }));
+    EXPECT_CALL(fetcher(), fetch(StrEq("/system/etc/vintf/compatibility_matrix.empty.xml"), _))
+        .WillOnce(Invoke([](const auto&, auto& out) {
+            out = "<compatibility-matrix version=\"1.0\" type=\"framework\"/>";
+            return ::android::OK;
+        }));
+    EXPECT_CALL(fetcher(), fetch(StrEq("/system/compatibility_matrix.xml"), _)).Times(0);
+
+    EXPECT_NE(nullptr, VintfObject::GetFrameworkCompatibilityMatrix(true /* skipCache */));
+}
+
 int main(int argc, char** argv) {
     ::testing::InitGoogleMock(&argc, argv);
 
diff --git a/utils.h b/utils.h
index 5f28b6d..c3dcd53 100644
--- a/utils.h
+++ b/utils.h
@@ -17,8 +17,11 @@
 #ifndef ANDROID_VINTF_UTILS_H
 #define ANDROID_VINTF_UTILS_H
 
+#include <dirent.h>
+
 #include <fstream>
 #include <iostream>
+#include <memory>
 #include <sstream>
 
 #include <utils/Errors.h>
@@ -58,6 +61,24 @@ class FileFetcher {
     virtual status_t fetch(const std::string& path, std::string& fetched) {
         return fetchInternal(path, fetched, nullptr);
     }
+    virtual status_t listFiles(const std::string& path, std::vector<std::string>* out,
+                               std::string* error) {
+        std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(path.c_str()), closedir);
+        if (!dir) {
+            if (error) {
+                *error = "Cannot open " + path;
+            }
+            return NAME_NOT_FOUND;
+        }
+
+        dirent* dp;
+        while ((dp = readdir(dir.get())) != nullptr) {
+            if (dp->d_type != DT_DIR) {
+                out->push_back(dp->d_name);
+            }
+        }
+        return OK;
+    }
 };
 
 extern FileFetcher* gFetcher;