blob: 52311837507aea4c3bbdf5bc950872d07fee32f9 [file] [log] [blame]
Yifan Hong3daec812017-02-27 18:49:11 -08001/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "VintfObject.h"
18
Yifan Hong143cfe62017-04-13 20:18:01 -070019#include "CompatibilityMatrix.h"
Yifan Hongf73ba512018-01-17 15:52:30 -080020#include "parse_string.h"
Yifan Hong143cfe62017-04-13 20:18:01 -070021#include "parse_xml.h"
Yifan Hong8640cd12017-05-17 12:02:28 -070022#include "utils.h"
Yifan Hong143cfe62017-04-13 20:18:01 -070023
Yifan Hongd52bf3e2018-01-11 16:56:51 -080024#include <dirent.h>
25
Yifan Hong3daec812017-02-27 18:49:11 -080026#include <functional>
27#include <memory>
28#include <mutex>
29
Yifan Hong60217032018-01-08 16:19:42 -080030#include <android-base/logging.h>
31
32using std::placeholders::_1;
33using std::placeholders::_2;
34
Yifan Hong3daec812017-02-27 18:49:11 -080035namespace android {
36namespace vintf {
37
Yifan Hong270b5652018-01-18 18:46:01 -080038using namespace details;
39
Yifan Hong9f78c182018-07-12 14:45:52 -070040#ifdef LIBVINTF_TARGET
41static constexpr bool kIsTarget = true;
42#else
43static constexpr bool kIsTarget = false;
44#endif
Yifan Hong1fb004e2017-09-26 15:04:44 -070045
Yifan Hong3daec812017-02-27 18:49:11 -080046template <typename T, typename F>
Yifan Hongfc73edf2017-08-29 11:39:07 -070047static std::shared_ptr<const T> Get(
48 LockedSharedPtr<T> *ptr,
Yifan Hong143cfe62017-04-13 20:18:01 -070049 bool skipCache,
Yifan Hong3daec812017-02-27 18:49:11 -080050 const F &fetchAllInformation) {
51 std::unique_lock<std::mutex> _lock(ptr->mutex);
Yifan Hong7219ba12018-01-08 16:23:49 -080052 if (skipCache || !ptr->fetchedOnce) {
Yifan Hong3daec812017-02-27 18:49:11 -080053 ptr->object = std::make_unique<T>();
Yifan Hong60217032018-01-08 16:19:42 -080054 std::string error;
55 if (fetchAllInformation(ptr->object.get(), &error) != OK) {
56 LOG(WARNING) << error;
Yifan Hong3daec812017-02-27 18:49:11 -080057 ptr->object = nullptr; // frees the old object
58 }
Yifan Hong7219ba12018-01-08 16:23:49 -080059 ptr->fetchedOnce = true;
Yifan Hong3daec812017-02-27 18:49:11 -080060 }
Yifan Hongfc73edf2017-08-29 11:39:07 -070061 return ptr->object;
Yifan Hong3daec812017-02-27 18:49:11 -080062}
63
Yifan Hong9f78c182018-07-12 14:45:52 -070064static std::unique_ptr<FileSystem> createDefaultFileSystem() {
65 std::unique_ptr<FileSystem> fileSystem;
66 if (kIsTarget) {
67 fileSystem = std::make_unique<details::FileSystemImpl>();
68 } else {
69 fileSystem = std::make_unique<details::FileSystemNoOp>();
70 }
71 return fileSystem;
72}
73
74static std::unique_ptr<PropertyFetcher> createDefaultPropertyFetcher() {
75 std::unique_ptr<PropertyFetcher> propertyFetcher;
76 if (kIsTarget) {
77 propertyFetcher = std::make_unique<details::PropertyFetcherImpl>();
78 } else {
79 propertyFetcher = std::make_unique<details::PropertyFetcherNoOp>();
80 }
81 return propertyFetcher;
82}
83
84VintfObject::VintfObject(std::unique_ptr<FileSystem>&& fileSystem,
85 std::unique_ptr<details::PartitionMounter>&& partitionMounter,
86 std::unique_ptr<details::ObjectFactory<RuntimeInfo>>&& runtimeInfoFactory,
87 std::unique_ptr<details::PropertyFetcher>&& propertyFetcher)
88 : mFileSystem(fileSystem ? std::move(fileSystem) : createDefaultFileSystem()),
89 mPartitionMounter(partitionMounter ? std::move(partitionMounter)
90 : std::make_unique<details::PartitionMounter>()),
91 mRuntimeInfoFactory(runtimeInfoFactory
92 ? std::move(runtimeInfoFactory)
93 : std::make_unique<details::ObjectFactory<RuntimeInfo>>()),
94 mPropertyFetcher(propertyFetcher ? std::move(propertyFetcher)
95 : createDefaultPropertyFetcher()) {}
96
97details::LockedSharedPtr<VintfObject> VintfObject::sInstance{};
98std::shared_ptr<VintfObject> VintfObject::GetInstance() {
99 std::unique_lock<std::mutex> lock(sInstance.mutex);
100 if (sInstance.object == nullptr) {
101 sInstance.object = std::make_shared<VintfObject>();
102 }
103 return sInstance.object;
104}
105
Yifan Hongfc73edf2017-08-29 11:39:07 -0700106std::shared_ptr<const HalManifest> VintfObject::GetDeviceHalManifest(bool skipCache) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700107 return GetInstance()->getDeviceHalManifest(skipCache);
Yifan Hong3daec812017-02-27 18:49:11 -0800108}
109
Yifan Hong9f78c182018-07-12 14:45:52 -0700110std::shared_ptr<const HalManifest> VintfObject::getDeviceHalManifest(bool skipCache) {
111 return Get(&mDeviceManifest, skipCache,
112 std::bind(&VintfObject::fetchDeviceHalManifest, this, _1, _2));
113}
114
Yifan Hongfc73edf2017-08-29 11:39:07 -0700115std::shared_ptr<const HalManifest> VintfObject::GetFrameworkHalManifest(bool skipCache) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700116 return GetInstance()->getFrameworkHalManifest(skipCache);
Yifan Hong3daec812017-02-27 18:49:11 -0800117}
118
Yifan Hong9f78c182018-07-12 14:45:52 -0700119std::shared_ptr<const HalManifest> VintfObject::getFrameworkHalManifest(bool skipCache) {
120 return Get(&mFrameworkManifest, skipCache,
121 std::bind(&VintfObject::fetchFrameworkHalManifest, this, _1, _2));
122}
Yifan Hong2272bf82017-04-28 14:37:56 -0700123
Yifan Hongfc73edf2017-08-29 11:39:07 -0700124std::shared_ptr<const CompatibilityMatrix> VintfObject::GetDeviceCompatibilityMatrix(bool skipCache) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700125 return GetInstance()->getDeviceCompatibilityMatrix(skipCache);
Yifan Hong2272bf82017-04-28 14:37:56 -0700126}
127
Yifan Hong9f78c182018-07-12 14:45:52 -0700128std::shared_ptr<const CompatibilityMatrix> VintfObject::getDeviceCompatibilityMatrix(
129 bool skipCache) {
130 return Get(&mDeviceMatrix, skipCache, std::bind(&VintfObject::fetchDeviceMatrix, this, _1, _2));
131}
132
Yifan Hongfc73edf2017-08-29 11:39:07 -0700133std::shared_ptr<const CompatibilityMatrix> VintfObject::GetFrameworkCompatibilityMatrix(bool skipCache) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700134 return GetInstance()->getFrameworkCompatibilityMatrix(skipCache);
135}
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800136
Yifan Hong9f78c182018-07-12 14:45:52 -0700137std::shared_ptr<const CompatibilityMatrix> VintfObject::getFrameworkCompatibilityMatrix(
138 bool skipCache) {
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800139 // To avoid deadlock, get device manifest before any locks.
Yifan Hong9f78c182018-07-12 14:45:52 -0700140 auto deviceManifest = getDeviceHalManifest();
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800141
Yifan Hong9f78c182018-07-12 14:45:52 -0700142 std::unique_lock<std::mutex> _lock(mFrameworkCompatibilityMatrixMutex);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800143
144 auto combined =
Yifan Hong9f78c182018-07-12 14:45:52 -0700145 Get(&mCombinedFrameworkMatrix, skipCache,
146 std::bind(&VintfObject::getCombinedFrameworkMatrix, this, deviceManifest, _1, _2));
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800147 if (combined != nullptr) {
148 return combined;
149 }
150
Yifan Hong9f78c182018-07-12 14:45:52 -0700151 return Get(&mFrameworkMatrix, skipCache,
152 std::bind(&CompatibilityMatrix::fetchAllInformation, _1, mFileSystem.get(),
153 kSystemLegacyMatrix, _2));
Yifan Hong2272bf82017-04-28 14:37:56 -0700154}
155
Yifan Hong9f78c182018-07-12 14:45:52 -0700156status_t VintfObject::getCombinedFrameworkMatrix(
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800157 const std::shared_ptr<const HalManifest>& deviceManifest, CompatibilityMatrix* out,
158 std::string* error) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700159 auto matrixFragments = getAllFrameworkMatrixLevels(error);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800160 if (matrixFragments.empty()) {
161 return NAME_NOT_FOUND;
162 }
163
164 Level deviceLevel = Level::UNSPECIFIED;
165
166 if (deviceManifest != nullptr) {
167 deviceLevel = deviceManifest->level();
168 }
169
170 // TODO(b/70628538): Do not infer from Shipping API level.
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800171 if (deviceLevel == Level::UNSPECIFIED) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700172 auto shippingApi = mPropertyFetcher->getUintProperty("ro.product.first_api_level", 0u);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800173 if (shippingApi != 0u) {
174 deviceLevel = details::convertFromApiLevel(shippingApi);
175 }
176 }
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800177
178 if (deviceLevel == Level::UNSPECIFIED) {
179 // Cannot infer FCM version. Combine all matrices by assuming
180 // Shipping FCM Version == min(all supported FCM Versions in the framework)
181 for (auto&& pair : matrixFragments) {
182 Level fragmentLevel = pair.object.level();
183 if (fragmentLevel != Level::UNSPECIFIED && deviceLevel > fragmentLevel) {
184 deviceLevel = fragmentLevel;
185 }
186 }
187 }
188
189 if (deviceLevel == Level::UNSPECIFIED) {
190 // None of the fragments specify any FCM version. Should never happen except
191 // for inconsistent builds.
192 if (error) {
Yifan Hong270b5652018-01-18 18:46:01 -0800193 *error = "No framework compatibility matrix files under " + kSystemVintfDir +
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800194 " declare FCM version.";
195 }
196 return NAME_NOT_FOUND;
197 }
198
Yifan Honge7837b12018-10-11 10:38:57 -0700199 auto combined = CompatibilityMatrix::combine(deviceLevel, &matrixFragments, error);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800200 if (combined == nullptr) {
201 return BAD_VALUE;
202 }
203 *out = std::move(*combined);
204 return OK;
205}
206
Steven Morelandeedf2d42018-04-04 16:36:27 -0700207// Load and combine all of the manifests in a directory
Yifan Hong9f78c182018-07-12 14:45:52 -0700208status_t VintfObject::addDirectoryManifests(const std::string& directory, HalManifest* manifest,
Steven Morelandeedf2d42018-04-04 16:36:27 -0700209 std::string* error) {
210 std::vector<std::string> fileNames;
Yifan Hong9f78c182018-07-12 14:45:52 -0700211 status_t err = mFileSystem->listFiles(directory, &fileNames, error);
Steven Morelandeedf2d42018-04-04 16:36:27 -0700212 // if the directory isn't there, that's okay
213 if (err == NAME_NOT_FOUND) return OK;
214 if (err != OK) return err;
215
216 for (const std::string& file : fileNames) {
217 // Only adds HALs because all other things are added by libvintf
218 // itself for now.
219 HalManifest fragmentManifest;
Yifan Hong9f78c182018-07-12 14:45:52 -0700220 err = fetchOneHalManifest(directory + file, &fragmentManifest, error);
Steven Morelandeedf2d42018-04-04 16:36:27 -0700221 if (err != OK) return err;
222
223 manifest->addAllHals(&fragmentManifest);
224 }
225
226 return OK;
227}
228
Yifan Hong5a93bf22018-01-17 18:22:32 -0800229// Priority for loading vendor manifest:
Steven Morelandeedf2d42018-04-04 16:36:27 -0700230// 1. /vendor/etc/vintf/manifest.xml + device fragments + ODM manifest (optional) + odm fragments
231// 2. /vendor/etc/vintf/manifest.xml + device fragments
232// 3. ODM manifest (optional) + odm fragments
233// 4. /vendor/manifest.xml (legacy, no fragments)
Yifan Hong5a93bf22018-01-17 18:22:32 -0800234// where:
Steven Moreland30a532c2018-11-01 08:46:32 -0700235// A + B means unioning <hal> tags from A and B. If B declares an override, then this takes priority
236// over A.
Yifan Hong9f78c182018-07-12 14:45:52 -0700237status_t VintfObject::fetchDeviceHalManifest(HalManifest* out, std::string* error) {
238 status_t vendorStatus = fetchOneHalManifest(kVendorManifest, out, error);
Yifan Hong5a93bf22018-01-17 18:22:32 -0800239 if (vendorStatus != OK && vendorStatus != NAME_NOT_FOUND) {
240 return vendorStatus;
241 }
242
Steven Morelandeedf2d42018-04-04 16:36:27 -0700243 if (vendorStatus == OK) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700244 status_t fragmentStatus = addDirectoryManifests(kVendorManifestFragmentDir, out, error);
Steven Morelandeedf2d42018-04-04 16:36:27 -0700245 if (fragmentStatus != OK) {
246 return fragmentStatus;
247 }
248 }
249
Yifan Hong5a93bf22018-01-17 18:22:32 -0800250 HalManifest odmManifest;
Yifan Hong9f78c182018-07-12 14:45:52 -0700251 status_t odmStatus = fetchOdmHalManifest(&odmManifest, error);
Yifan Hong12a11ac2018-01-19 13:58:32 -0800252 if (odmStatus != OK && odmStatus != NAME_NOT_FOUND) {
253 return odmStatus;
Yifan Hong5a93bf22018-01-17 18:22:32 -0800254 }
255
Yifan Hong5a93bf22018-01-17 18:22:32 -0800256 if (vendorStatus == OK) {
Yifan Hong12a11ac2018-01-19 13:58:32 -0800257 if (odmStatus == OK) {
258 out->addAllHals(&odmManifest);
259 }
Yifan Hong9f78c182018-07-12 14:45:52 -0700260 return addDirectoryManifests(kOdmManifestFragmentDir, out, error);
Yifan Hong5a93bf22018-01-17 18:22:32 -0800261 }
262
Yifan Hong12a11ac2018-01-19 13:58:32 -0800263 // vendorStatus != OK, "out" is not changed.
Yifan Hong5a93bf22018-01-17 18:22:32 -0800264 if (odmStatus == OK) {
265 *out = std::move(odmManifest);
Yifan Hong9f78c182018-07-12 14:45:52 -0700266 return addDirectoryManifests(kOdmManifestFragmentDir, out, error);
Yifan Hong5a93bf22018-01-17 18:22:32 -0800267 }
268
269 // Use legacy /vendor/manifest.xml
Yifan Hong9f78c182018-07-12 14:45:52 -0700270 return out->fetchAllInformation(mFileSystem.get(), kVendorLegacyManifest, error);
Yifan Hong5a93bf22018-01-17 18:22:32 -0800271}
272
Yifan Hong12a11ac2018-01-19 13:58:32 -0800273// "out" is written to iff return status is OK.
274// Priority:
275// 1. if {sku} is defined, /odm/etc/vintf/manifest_{sku}.xml
276// 2. /odm/etc/vintf/manifest.xml
277// 3. if {sku} is defined, /odm/etc/manifest_{sku}.xml
278// 4. /odm/etc/manifest.xml
279// where:
280// {sku} is the value of ro.boot.product.hardware.sku
Yifan Hong9f78c182018-07-12 14:45:52 -0700281status_t VintfObject::fetchOdmHalManifest(HalManifest* out, std::string* error) {
Yifan Hong12a11ac2018-01-19 13:58:32 -0800282 status_t status;
283
Yifan Hong12a11ac2018-01-19 13:58:32 -0800284 std::string productModel;
Yifan Hong9f78c182018-07-12 14:45:52 -0700285 productModel = mPropertyFetcher->getProperty("ro.boot.product.hardware.sku", "");
Yifan Hong12a11ac2018-01-19 13:58:32 -0800286
287 if (!productModel.empty()) {
288 status =
Yifan Hong9f78c182018-07-12 14:45:52 -0700289 fetchOneHalManifest(kOdmVintfDir + "manifest_" + productModel + ".xml", out, error);
Yifan Hong12a11ac2018-01-19 13:58:32 -0800290 if (status == OK || status != NAME_NOT_FOUND) {
291 return status;
292 }
293 }
Yifan Hong12a11ac2018-01-19 13:58:32 -0800294
Yifan Hong9f78c182018-07-12 14:45:52 -0700295 status = fetchOneHalManifest(kOdmManifest, out, error);
Yifan Hong12a11ac2018-01-19 13:58:32 -0800296 if (status == OK || status != NAME_NOT_FOUND) {
297 return status;
298 }
299
Yifan Hong12a11ac2018-01-19 13:58:32 -0800300 if (!productModel.empty()) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700301 status = fetchOneHalManifest(kOdmLegacyVintfDir + "manifest_" + productModel + ".xml", out,
Yifan Hong12a11ac2018-01-19 13:58:32 -0800302 error);
303 if (status == OK || status != NAME_NOT_FOUND) {
304 return status;
305 }
306 }
Yifan Hong12a11ac2018-01-19 13:58:32 -0800307
Yifan Hong9f78c182018-07-12 14:45:52 -0700308 status = fetchOneHalManifest(kOdmLegacyManifest, out, error);
Yifan Hong12a11ac2018-01-19 13:58:32 -0800309 if (status == OK || status != NAME_NOT_FOUND) {
310 return status;
311 }
312
313 return NAME_NOT_FOUND;
314}
315
316// Fetch one manifest.xml file. "out" is written to iff return status is OK.
317// Returns NAME_NOT_FOUND if file is missing.
Yifan Hong9f78c182018-07-12 14:45:52 -0700318status_t VintfObject::fetchOneHalManifest(const std::string& path, HalManifest* out,
Yifan Hong12a11ac2018-01-19 13:58:32 -0800319 std::string* error) {
320 HalManifest ret;
Yifan Hong9f78c182018-07-12 14:45:52 -0700321 status_t status = ret.fetchAllInformation(mFileSystem.get(), path, error);
Yifan Hong12a11ac2018-01-19 13:58:32 -0800322 if (status == OK) {
323 *out = std::move(ret);
324 }
325 return status;
326}
327
Yifan Hong9f78c182018-07-12 14:45:52 -0700328status_t VintfObject::fetchDeviceMatrix(CompatibilityMatrix* out, std::string* error) {
Yifan Hongb64ec9e2018-01-18 18:57:52 -0800329 CompatibilityMatrix etcMatrix;
Yifan Hong9f78c182018-07-12 14:45:52 -0700330 if (etcMatrix.fetchAllInformation(mFileSystem.get(), kVendorMatrix, error) == OK) {
Yifan Hongb64ec9e2018-01-18 18:57:52 -0800331 *out = std::move(etcMatrix);
332 return OK;
333 }
Yifan Hong9f78c182018-07-12 14:45:52 -0700334 return out->fetchAllInformation(mFileSystem.get(), kVendorLegacyMatrix, error);
Yifan Hongb64ec9e2018-01-18 18:57:52 -0800335}
336
Yifan Hong9f78c182018-07-12 14:45:52 -0700337status_t VintfObject::fetchFrameworkHalManifest(HalManifest* out, std::string* error) {
Yifan Hongde6d00e2018-02-27 17:11:28 -0800338 HalManifest etcManifest;
Yifan Hong9f78c182018-07-12 14:45:52 -0700339 if (etcManifest.fetchAllInformation(mFileSystem.get(), kSystemManifest, error) == OK) {
Yifan Hongde6d00e2018-02-27 17:11:28 -0800340 *out = std::move(etcManifest);
Yifan Hong9f78c182018-07-12 14:45:52 -0700341 return addDirectoryManifests(kSystemManifestFragmentDir, out, error);
Yifan Hongde6d00e2018-02-27 17:11:28 -0800342 }
Yifan Hong9f78c182018-07-12 14:45:52 -0700343 return out->fetchAllInformation(mFileSystem.get(), kSystemLegacyManifest, error);
Yifan Hongde6d00e2018-02-27 17:11:28 -0800344}
345
Yifan Hong9f8f6562018-11-06 16:26:20 -0800346static void appendLine(std::string* error, const std::string& message) {
347 if (error != nullptr) {
348 if (!error->empty()) *error += "\n";
349 *error += message;
350 }
351}
352
Yifan Hong9f78c182018-07-12 14:45:52 -0700353std::vector<Named<CompatibilityMatrix>> VintfObject::getAllFrameworkMatrixLevels(
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800354 std::string* error) {
355 std::vector<std::string> fileNames;
356 std::vector<Named<CompatibilityMatrix>> results;
357
Yifan Hong9f78c182018-07-12 14:45:52 -0700358 if (mFileSystem->listFiles(kSystemVintfDir, &fileNames, error) != OK) {
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800359 return {};
360 }
361 for (const std::string& fileName : fileNames) {
Yifan Hong270b5652018-01-18 18:46:01 -0800362 std::string path = kSystemVintfDir + fileName;
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800363
364 std::string content;
365 std::string fetchError;
Yifan Hong9f78c182018-07-12 14:45:52 -0700366 status_t status = mFileSystem->fetch(path, &content, &fetchError);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800367 if (status != OK) {
Yifan Hong9f8f6562018-11-06 16:26:20 -0800368 appendLine(error, "Framework Matrix: Ignore file " + path + ": " + fetchError);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800369 continue;
370 }
371
372 auto it = results.emplace(results.end());
Yifan Hong9f8f6562018-11-06 16:26:20 -0800373 std::string parseError;
374 if (!gCompatibilityMatrixConverter(&it->object, content, &parseError)) {
375 appendLine(error, "Framework Matrix: Ignore file " + path + ": " + parseError);
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800376 results.erase(it);
377 continue;
378 }
379 }
380
381 if (results.empty()) {
382 if (error) {
Yifan Hong9f8f6562018-11-06 16:26:20 -0800383 error->insert(0, "No framework matrices under " + kSystemVintfDir +
384 " can be fetched or parsed.\n");
Yifan Hongd52bf3e2018-01-11 16:56:51 -0800385 }
386 } else {
387 if (error && !error->empty()) {
388 LOG(WARNING) << *error;
389 *error = "";
390 }
391 }
392
393 return results;
394}
395
Yifan Hong1fb004e2017-09-26 15:04:44 -0700396std::shared_ptr<const RuntimeInfo> VintfObject::GetRuntimeInfo(bool skipCache,
397 RuntimeInfo::FetchFlags flags) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700398 return GetInstance()->getRuntimeInfo(skipCache, flags);
399}
400std::shared_ptr<const RuntimeInfo> VintfObject::getRuntimeInfo(bool skipCache,
401 RuntimeInfo::FetchFlags flags) {
402 std::unique_lock<std::mutex> _lock(mDeviceRuntimeInfo.mutex);
Yifan Hong1fb004e2017-09-26 15:04:44 -0700403
404 if (!skipCache) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700405 flags &= (~mDeviceRuntimeInfo.fetchedFlags);
Yifan Hong1fb004e2017-09-26 15:04:44 -0700406 }
407
Yifan Hong9f78c182018-07-12 14:45:52 -0700408 if (mDeviceRuntimeInfo.object == nullptr) {
409 mDeviceRuntimeInfo.object = mRuntimeInfoFactory->make_shared();
Yifan Hong1fb004e2017-09-26 15:04:44 -0700410 }
411
Yifan Hong9f78c182018-07-12 14:45:52 -0700412 status_t status = mDeviceRuntimeInfo.object->fetchAllInformation(flags);
Yifan Hong1fb004e2017-09-26 15:04:44 -0700413 if (status != OK) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700414 mDeviceRuntimeInfo.fetchedFlags &= (~flags); // mark the fields as "not fetched"
Yifan Hong1fb004e2017-09-26 15:04:44 -0700415 return nullptr;
416 }
417
Yifan Hong9f78c182018-07-12 14:45:52 -0700418 mDeviceRuntimeInfo.fetchedFlags |= flags;
419 return mDeviceRuntimeInfo.object;
Yifan Hong3daec812017-02-27 18:49:11 -0800420}
421
Yifan Hong143cfe62017-04-13 20:18:01 -0700422namespace details {
423
Yifan Hong143cfe62017-04-13 20:18:01 -0700424enum class ParseStatus {
425 OK,
426 PARSE_ERROR,
427 DUPLICATED_FWK_ENTRY,
428 DUPLICATED_DEV_ENTRY,
429};
430
Yifan Hong9532bd22017-04-14 15:30:52 -0700431static std::string toString(ParseStatus status) {
Yifan Hong143cfe62017-04-13 20:18:01 -0700432 switch(status) {
433 case ParseStatus::OK: return "OK";
434 case ParseStatus::PARSE_ERROR: return "parse error";
435 case ParseStatus::DUPLICATED_FWK_ENTRY: return "duplicated framework";
436 case ParseStatus::DUPLICATED_DEV_ENTRY: return "duplicated device";
437 }
438 return "";
439}
440
441template<typename T>
Yifan Hong9532bd22017-04-14 15:30:52 -0700442static ParseStatus tryParse(const std::string &xml, const XmlConverter<T> &parse,
Yifan Hongfc73edf2017-08-29 11:39:07 -0700443 std::shared_ptr<T> *fwk, std::shared_ptr<T> *dev) {
444 std::shared_ptr<T> ret = std::make_shared<T>();
Yifan Hong94757062018-02-09 16:36:31 -0800445 if (!parse(ret.get(), xml, nullptr /* error */)) {
Yifan Hong143cfe62017-04-13 20:18:01 -0700446 return ParseStatus::PARSE_ERROR;
447 }
448 if (ret->type() == SchemaType::FRAMEWORK) {
449 if (fwk->get() != nullptr) {
450 return ParseStatus::DUPLICATED_FWK_ENTRY;
451 }
452 *fwk = std::move(ret);
453 } else if (ret->type() == SchemaType::DEVICE) {
454 if (dev->get() != nullptr) {
455 return ParseStatus::DUPLICATED_DEV_ENTRY;
456 }
457 *dev = std::move(ret);
458 }
459 return ParseStatus::OK;
460}
461
Yifan Hong878556e2018-07-13 13:45:30 -0700462template <typename T, typename GetFunction>
463static status_t getMissing(const std::string& msg, const std::shared_ptr<T>& pkg, bool mount,
464 std::function<status_t(void)> mountFunction,
465 std::shared_ptr<const T>* updated, GetFunction getFunction,
466 std::string* error) {
Yifan Hong143cfe62017-04-13 20:18:01 -0700467 if (pkg != nullptr) {
468 *updated = pkg;
469 } else {
470 if (mount) {
Yifan Hong878556e2018-07-13 13:45:30 -0700471 status_t mountStatus = mountFunction();
472 if (mountStatus != OK) {
473 appendLine(error, "warning: mount " + msg + " failed: " + strerror(-mountStatus));
474 }
Yifan Hong143cfe62017-04-13 20:18:01 -0700475 }
476 *updated = getFunction();
477 }
478 return OK;
479}
480
Yifan Hong143cfe62017-04-13 20:18:01 -0700481struct PackageInfo {
482 struct Pair {
Yifan Hongfc73edf2017-08-29 11:39:07 -0700483 std::shared_ptr<HalManifest> manifest;
484 std::shared_ptr<CompatibilityMatrix> matrix;
Yifan Hong143cfe62017-04-13 20:18:01 -0700485 };
486 Pair dev;
487 Pair fwk;
488};
489
490struct UpdatedInfo {
491 struct Pair {
Yifan Hongfc73edf2017-08-29 11:39:07 -0700492 std::shared_ptr<const HalManifest> manifest;
493 std::shared_ptr<const CompatibilityMatrix> matrix;
Yifan Hong143cfe62017-04-13 20:18:01 -0700494 };
495 Pair dev;
496 Pair fwk;
Yifan Hongfc73edf2017-08-29 11:39:07 -0700497 std::shared_ptr<const RuntimeInfo> runtimeInfo;
Yifan Hong143cfe62017-04-13 20:18:01 -0700498};
499
Yifan Hong9f78c182018-07-12 14:45:52 -0700500} // namespace details
501
Michael Schwartz97dc0f92017-05-08 14:07:14 -0700502// Checks given compatibility info against info on the device. If no
503// compatability info is given then the device info will be checked against
504// itself.
Yifan Hong9f78c182018-07-12 14:45:52 -0700505int32_t VintfObject::checkCompatibility(const std::vector<std::string>& xmls, bool mount,
Yifan Hong072f12d2018-08-08 13:04:51 -0700506 std::string* error, CheckFlags::Type flags) {
Yifan Hong143cfe62017-04-13 20:18:01 -0700507 status_t status;
508 ParseStatus parseStatus;
509 PackageInfo pkg; // All information from package.
510 UpdatedInfo updated; // All files and runtime info after the update.
511
Yifan Hong143cfe62017-04-13 20:18:01 -0700512 // parse all information from package
513 for (const auto &xml : xmls) {
514 parseStatus = tryParse(xml, gHalManifestConverter, &pkg.fwk.manifest, &pkg.dev.manifest);
515 if (parseStatus == ParseStatus::OK) {
516 continue; // work on next one
517 }
518 if (parseStatus != ParseStatus::PARSE_ERROR) {
Yifan Hong878556e2018-07-13 13:45:30 -0700519 appendLine(error, toString(parseStatus) + " manifest");
Yifan Hong143cfe62017-04-13 20:18:01 -0700520 return ALREADY_EXISTS;
521 }
522 parseStatus = tryParse(xml, gCompatibilityMatrixConverter, &pkg.fwk.matrix, &pkg.dev.matrix);
523 if (parseStatus == ParseStatus::OK) {
524 continue; // work on next one
525 }
526 if (parseStatus != ParseStatus::PARSE_ERROR) {
Yifan Hong878556e2018-07-13 13:45:30 -0700527 appendLine(error, toString(parseStatus) + " matrix");
Yifan Hong143cfe62017-04-13 20:18:01 -0700528 return ALREADY_EXISTS;
529 }
Yifan Hong878556e2018-07-13 13:45:30 -0700530 appendLine(error, toString(parseStatus)); // parse error
Yifan Hong143cfe62017-04-13 20:18:01 -0700531 return BAD_VALUE;
532 }
533
534 // get missing info from device
Yifan Hong8640cd12017-05-17 12:02:28 -0700535 // use functions instead of std::bind because std::bind doesn't work well with mock objects
Yifan Hong9f78c182018-07-12 14:45:52 -0700536 auto mountSystem = [this] { return this->mPartitionMounter->mountSystem(); };
537 auto mountVendor = [this] { return this->mPartitionMounter->mountVendor(); };
Yifan Hong8640cd12017-05-17 12:02:28 -0700538 if ((status = getMissing(
Yifan Hong878556e2018-07-13 13:45:30 -0700539 "system", pkg.fwk.manifest, mount, mountSystem, &updated.fwk.manifest,
540 std::bind(&VintfObject::getFrameworkHalManifest, this, true /* skipCache */),
541 error)) != OK) {
542 return status;
543 }
544 if ((status =
545 getMissing("vendor", pkg.dev.manifest, mount, mountVendor, &updated.dev.manifest,
546 std::bind(&VintfObject::getDeviceHalManifest, this, true /* skipCache */),
547 error)) != OK) {
Yifan Hong143cfe62017-04-13 20:18:01 -0700548 return status;
549 }
Michael Schwartz97dc0f92017-05-08 14:07:14 -0700550 if ((status = getMissing(
Yifan Hong878556e2018-07-13 13:45:30 -0700551 "system", pkg.fwk.matrix, mount, mountSystem, &updated.fwk.matrix,
552 std::bind(&VintfObject::getFrameworkCompatibilityMatrix, this, true /* skipCache */),
553 error)) != OK) {
Yifan Hong8640cd12017-05-17 12:02:28 -0700554 return status;
555 }
Yifan Hong878556e2018-07-13 13:45:30 -0700556 if ((status = getMissing(
557 "vendor", pkg.dev.matrix, mount, mountVendor, &updated.dev.matrix,
558 std::bind(&VintfObject::getDeviceCompatibilityMatrix, this, true /* skipCache */),
559 error)) != OK) {
Michael Schwartz97dc0f92017-05-08 14:07:14 -0700560 return status;
561 }
Yifan Hong8640cd12017-05-17 12:02:28 -0700562
563 if (mount) {
Yifan Hong878556e2018-07-13 13:45:30 -0700564 status_t umountStatus = mPartitionMounter->umountSystem();
565 if (umountStatus != OK) {
566 appendLine(error,
567 std::string{"warning: umount system failed: "} + strerror(-umountStatus));
568 }
569 umountStatus = mPartitionMounter->umountVendor();
570 if (umountStatus != OK) {
571 appendLine(error,
572 std::string{"warning: umount vendor failed: "} + strerror(-umountStatus));
573 }
Yifan Hong8640cd12017-05-17 12:02:28 -0700574 }
575
Yifan Hong072f12d2018-08-08 13:04:51 -0700576 if (flags.isRuntimeInfoEnabled()) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700577 updated.runtimeInfo = getRuntimeInfo(true /* skipCache */);
Yifan Hong69c1b112018-02-27 17:06:00 -0800578 }
Yifan Hong143cfe62017-04-13 20:18:01 -0700579
580 // null checks for files and runtime info after the update
Yifan Hong143cfe62017-04-13 20:18:01 -0700581 if (updated.fwk.manifest == nullptr) {
Yifan Hong878556e2018-07-13 13:45:30 -0700582 appendLine(error, "No framework manifest file from device or from update package");
583 status = NO_INIT;
Yifan Hong143cfe62017-04-13 20:18:01 -0700584 }
585 if (updated.dev.manifest == nullptr) {
Yifan Hong878556e2018-07-13 13:45:30 -0700586 appendLine(error, "No device manifest file from device or from update package");
587 status = NO_INIT;
Yifan Hong143cfe62017-04-13 20:18:01 -0700588 }
589 if (updated.fwk.matrix == nullptr) {
Yifan Hong878556e2018-07-13 13:45:30 -0700590 appendLine(error, "No framework matrix file from device or from update package");
591 status = NO_INIT;
Yifan Hong143cfe62017-04-13 20:18:01 -0700592 }
593 if (updated.dev.matrix == nullptr) {
Yifan Hong878556e2018-07-13 13:45:30 -0700594 appendLine(error, "No device matrix file from device or from update package");
595 status = NO_INIT;
Yifan Hong143cfe62017-04-13 20:18:01 -0700596 }
Yifan Hong69c1b112018-02-27 17:06:00 -0800597
Yifan Hong072f12d2018-08-08 13:04:51 -0700598 if (flags.isRuntimeInfoEnabled()) {
Yifan Hong69c1b112018-02-27 17:06:00 -0800599 if (updated.runtimeInfo == nullptr) {
Yifan Hong878556e2018-07-13 13:45:30 -0700600 appendLine(error, "No runtime info from device");
601 status = NO_INIT;
Yifan Hong69c1b112018-02-27 17:06:00 -0800602 }
Yifan Hong143cfe62017-04-13 20:18:01 -0700603 }
Yifan Hong878556e2018-07-13 13:45:30 -0700604 if (status != OK) return status;
Yifan Hong143cfe62017-04-13 20:18:01 -0700605
606 // compatiblity check.
Yifan Hongca386fe2018-02-07 11:29:03 -0800607 if (!updated.dev.manifest->checkCompatibility(*updated.fwk.matrix, error)) {
608 if (error) {
609 error->insert(0,
610 "Device manifest and framework compatibility matrix are incompatible: ");
Yifan Hong143cfe62017-04-13 20:18:01 -0700611 }
Yifan Hongca386fe2018-02-07 11:29:03 -0800612 return INCOMPATIBLE;
Yifan Hong143cfe62017-04-13 20:18:01 -0700613 }
Yifan Hongca386fe2018-02-07 11:29:03 -0800614 if (!updated.fwk.manifest->checkCompatibility(*updated.dev.matrix, error)) {
615 if (error) {
616 error->insert(0,
617 "Framework manifest and device compatibility matrix are incompatible: ");
Yifan Hong143cfe62017-04-13 20:18:01 -0700618 }
Yifan Hongca386fe2018-02-07 11:29:03 -0800619 return INCOMPATIBLE;
Yifan Hong143cfe62017-04-13 20:18:01 -0700620 }
Yifan Hong69c1b112018-02-27 17:06:00 -0800621
Yifan Hong072f12d2018-08-08 13:04:51 -0700622 if (flags.isRuntimeInfoEnabled()) {
623 if (!updated.runtimeInfo->checkCompatibility(*updated.fwk.matrix, error, flags)) {
Yifan Hong69c1b112018-02-27 17:06:00 -0800624 if (error) {
625 error->insert(0,
626 "Runtime info and framework compatibility matrix are incompatible: ");
627 }
628 return INCOMPATIBLE;
Yifan Hong143cfe62017-04-13 20:18:01 -0700629 }
630 }
631
632 return COMPATIBLE;
633}
634
Yifan Hong9f78c182018-07-12 14:45:52 -0700635namespace details {
636
Yifan Hong270b5652018-01-18 18:46:01 -0800637const std::string kSystemVintfDir = "/system/etc/vintf/";
Yifan Hongccbea052018-01-18 18:48:46 -0800638const std::string kVendorVintfDir = "/vendor/etc/vintf/";
Yifan Hong12a11ac2018-01-19 13:58:32 -0800639const std::string kOdmVintfDir = "/odm/etc/vintf/";
Yifan Hong270b5652018-01-18 18:46:01 -0800640
641const std::string kVendorManifest = kVendorVintfDir + "manifest.xml";
Yifan Honga5ddddf2018-01-18 18:50:13 -0800642const std::string kSystemManifest = kSystemVintfDir + "manifest.xml";
Yifan Hongb64ec9e2018-01-18 18:57:52 -0800643const std::string kVendorMatrix = kVendorVintfDir + "compatibility_matrix.xml";
Yifan Hong12a11ac2018-01-19 13:58:32 -0800644const std::string kOdmManifest = kOdmVintfDir + "manifest.xml";
Yifan Hong270b5652018-01-18 18:46:01 -0800645
Steven Morelandeedf2d42018-04-04 16:36:27 -0700646const std::string kVendorManifestFragmentDir = kVendorVintfDir + "manifest/";
647const std::string kSystemManifestFragmentDir = kSystemVintfDir + "manifest/";
648const std::string kOdmManifestFragmentDir = kOdmVintfDir + "manifest/";
649
Yifan Hong270b5652018-01-18 18:46:01 -0800650const std::string kVendorLegacyManifest = "/vendor/manifest.xml";
651const std::string kVendorLegacyMatrix = "/vendor/compatibility_matrix.xml";
Yifan Hongde6d00e2018-02-27 17:11:28 -0800652const std::string kSystemLegacyManifest = "/system/manifest.xml";
Yifan Hong270b5652018-01-18 18:46:01 -0800653const std::string kSystemLegacyMatrix = "/system/compatibility_matrix.xml";
654const std::string kOdmLegacyVintfDir = "/odm/etc/";
655const std::string kOdmLegacyManifest = kOdmLegacyVintfDir + "manifest.xml";
656
Yifan Hong69c1b112018-02-27 17:06:00 -0800657std::vector<std::string> dumpFileList() {
658 return {
659 kSystemVintfDir, kVendorVintfDir, kOdmVintfDir, kOdmLegacyVintfDir,
660
661 kVendorLegacyManifest, kVendorLegacyMatrix, kSystemLegacyManifest, kSystemLegacyMatrix,
662 };
663}
664
Yifan Hong9f78c182018-07-12 14:45:52 -0700665} // namespace details
Yifan Hong143cfe62017-04-13 20:18:01 -0700666
Yifan Hongdb6423e2017-09-11 14:38:46 -0700667int32_t VintfObject::CheckCompatibility(const std::vector<std::string>& xmls, std::string* error,
Yifan Hong072f12d2018-08-08 13:04:51 -0700668 CheckFlags::Type flags) {
669 return GetInstance()->checkCompatibility(xmls, error, flags);
Yifan Hongfbbf0472017-04-07 18:14:18 -0700670}
671
Yifan Hong9f78c182018-07-12 14:45:52 -0700672int32_t VintfObject::checkCompatibility(const std::vector<std::string>& xmls, std::string* error,
Yifan Hong072f12d2018-08-08 13:04:51 -0700673 CheckFlags::Type flags) {
674 return checkCompatibility(xmls, false /* mount */, error, flags);
Yifan Hong9f78c182018-07-12 14:45:52 -0700675}
676
677bool VintfObject::IsHalDeprecated(const MatrixHal& oldMatrixHal,
Yifan Hongf73ba512018-01-17 15:52:30 -0800678 const CompatibilityMatrix& targetMatrix,
Yifan Honga8a8fa92018-03-20 14:42:43 -0700679 const ListInstances& listInstances, std::string* error) {
Yifan Hong7e9e04d2018-03-20 13:06:00 -0700680 bool isDeprecated = false;
681 oldMatrixHal.forEachInstance([&](const MatrixInstance& oldMatrixInstance) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700682 if (IsInstanceDeprecated(oldMatrixInstance, targetMatrix, listInstances, error)) {
Yifan Hong7e9e04d2018-03-20 13:06:00 -0700683 isDeprecated = true;
Yifan Hongf73ba512018-01-17 15:52:30 -0800684 }
Yifan Hong7e9e04d2018-03-20 13:06:00 -0700685 return !isDeprecated; // continue if no deprecated instance is found.
686 });
687 return isDeprecated;
Yifan Hongf73ba512018-01-17 15:52:30 -0800688}
689
Yifan Honga8a8fa92018-03-20 14:42:43 -0700690// Let oldMatrixInstance = package@x.y-w::interface with instancePattern.
691// If any "servedInstance" in listInstances(package@x.y::interface) matches instancePattern, return
692// true iff:
693// 1. package@x.?::interface/servedInstance is not in targetMatrix; OR
694// 2. package@x.z::interface/servedInstance is in targetMatrix but
695// servedInstance is not in listInstances(package@x.z::interface)
Yifan Hong9f78c182018-07-12 14:45:52 -0700696bool VintfObject::IsInstanceDeprecated(const MatrixInstance& oldMatrixInstance,
Yifan Hongf73ba512018-01-17 15:52:30 -0800697 const CompatibilityMatrix& targetMatrix,
Yifan Honga8a8fa92018-03-20 14:42:43 -0700698 const ListInstances& listInstances, std::string* error) {
Yifan Hong7e9e04d2018-03-20 13:06:00 -0700699 const std::string& package = oldMatrixInstance.package();
700 const Version& version = oldMatrixInstance.versionRange().minVer();
701 const std::string& interface = oldMatrixInstance.interface();
Yifan Hong7e9e04d2018-03-20 13:06:00 -0700702
Yifan Honga8a8fa92018-03-20 14:42:43 -0700703 std::vector<std::string> instanceHint;
704 if (!oldMatrixInstance.isRegex()) {
705 instanceHint.push_back(oldMatrixInstance.exactInstance());
706 }
707
708 auto list = listInstances(package, version, interface, instanceHint);
709 for (const auto& pair : list) {
710 const std::string& servedInstance = pair.first;
711 Version servedVersion = pair.second;
712 if (!oldMatrixInstance.matchInstance(servedInstance)) {
713 continue;
714 }
715
Yifan Hongf73ba512018-01-17 15:52:30 -0800716 // Find any package@x.? in target matrix, and check if instance is in target matrix.
Yifan Hong217f47e2018-03-15 12:34:05 -0700717 bool foundInstance = false;
718 Version targetMatrixMinVer;
719 targetMatrix.forEachInstanceOfPackage(package, [&](const auto& targetMatrixInstance) {
720 if (targetMatrixInstance.versionRange().majorVer == version.majorVer &&
721 targetMatrixInstance.interface() == interface &&
Yifan Honga8a8fa92018-03-20 14:42:43 -0700722 targetMatrixInstance.matchInstance(servedInstance)) {
Yifan Hong217f47e2018-03-15 12:34:05 -0700723 targetMatrixMinVer = targetMatrixInstance.versionRange().minVer();
724 foundInstance = true;
725 }
726 return !foundInstance; // continue if not found
727 });
728 if (!foundInstance) {
Yifan Hongf73ba512018-01-17 15:52:30 -0800729 if (error) {
Yifan Honga8a8fa92018-03-20 14:42:43 -0700730 *error = toFQNameString(package, servedVersion, interface, servedInstance) +
Steven Morelanda1b984c2018-03-09 13:09:15 -0800731 " is deprecated in compatibility matrix at FCM Version " +
Yifan Hongf73ba512018-01-17 15:52:30 -0800732 to_string(targetMatrix.level()) + "; it should not be served.";
733 }
734 return true;
735 }
736
Yifan Hongf73ba512018-01-17 15:52:30 -0800737 // Assuming that targetMatrix requires @x.u-v, require that at least @x.u is served.
Yifan Honga8a8fa92018-03-20 14:42:43 -0700738 bool targetVersionServed = false;
739 for (const auto& newPair :
740 listInstances(package, targetMatrixMinVer, interface, instanceHint)) {
741 if (newPair.first == servedInstance) {
742 targetVersionServed = true;
743 break;
744 }
745 }
Yifan Hongf73ba512018-01-17 15:52:30 -0800746
747 if (!targetVersionServed) {
Yifan Hong9f8f6562018-11-06 16:26:20 -0800748 appendLine(error, toFQNameString(package, servedVersion, interface, servedInstance) +
749 " is deprecated; requires at least " +
750 to_string(targetMatrixMinVer));
Yifan Hongf73ba512018-01-17 15:52:30 -0800751 return true;
752 }
753 }
Yifan Honga8a8fa92018-03-20 14:42:43 -0700754
Yifan Hongf73ba512018-01-17 15:52:30 -0800755 return false;
756}
757
Yifan Honga8a8fa92018-03-20 14:42:43 -0700758int32_t VintfObject::CheckDeprecation(const ListInstances& listInstances, std::string* error) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700759 return GetInstance()->checkDeprecation(listInstances, error);
760}
761int32_t VintfObject::checkDeprecation(const ListInstances& listInstances, std::string* error) {
762 auto matrixFragments = getAllFrameworkMatrixLevels(error);
Yifan Hongf73ba512018-01-17 15:52:30 -0800763 if (matrixFragments.empty()) {
764 if (error && error->empty())
765 *error = "Cannot get framework matrix for each FCM version for unknown error.";
766 return NAME_NOT_FOUND;
767 }
Yifan Hong9f78c182018-07-12 14:45:52 -0700768 auto deviceManifest = getDeviceHalManifest();
Yifan Hongf73ba512018-01-17 15:52:30 -0800769 if (deviceManifest == nullptr) {
770 if (error) *error = "No device manifest.";
771 return NAME_NOT_FOUND;
772 }
773 Level deviceLevel = deviceManifest->level();
774 if (deviceLevel == Level::UNSPECIFIED) {
775 if (error) *error = "Device manifest does not specify Shipping FCM Version.";
776 return BAD_VALUE;
777 }
778
779 const CompatibilityMatrix* targetMatrix = nullptr;
780 for (const auto& namedMatrix : matrixFragments) {
781 if (namedMatrix.object.level() == deviceLevel) {
782 targetMatrix = &namedMatrix.object;
783 }
784 }
785 if (targetMatrix == nullptr) {
786 if (error)
787 *error = "Cannot find framework matrix at FCM version " + to_string(deviceLevel) + ".";
788 return NAME_NOT_FOUND;
789 }
790
791 bool hasDeprecatedHals = false;
792 for (const auto& namedMatrix : matrixFragments) {
793 if (namedMatrix.object.level() == Level::UNSPECIFIED) continue;
794 if (namedMatrix.object.level() >= deviceLevel) continue;
795
796 const auto& oldMatrix = namedMatrix.object;
797 for (const MatrixHal& hal : oldMatrix.getHals()) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700798 hasDeprecatedHals |= IsHalDeprecated(hal, *targetMatrix, listInstances, error);
Yifan Hongf73ba512018-01-17 15:52:30 -0800799 }
800 }
801
802 return hasDeprecatedHals ? DEPRECATED : NO_DEPRECATED_HALS;
803}
804
805int32_t VintfObject::CheckDeprecation(std::string* error) {
Yifan Hong9f78c182018-07-12 14:45:52 -0700806 return GetInstance()->checkDeprecation(error);
807}
808int32_t VintfObject::checkDeprecation(std::string* error) {
Yifan Hong2a90ffe2018-03-05 17:45:34 -0800809 using namespace std::placeholders;
Yifan Hong9f78c182018-07-12 14:45:52 -0700810 auto deviceManifest = getDeviceHalManifest();
Yifan Honga8a8fa92018-03-20 14:42:43 -0700811 ListInstances inManifest =
812 [&deviceManifest](const std::string& package, Version version, const std::string& interface,
813 const std::vector<std::string>& /* hintInstances */) {
814 std::vector<std::pair<std::string, Version>> ret;
815 deviceManifest->forEachInstanceOfInterface(
816 package, version, interface, [&ret](const ManifestInstance& manifestInstance) {
817 ret.push_back(
818 std::make_pair(manifestInstance.instance(), manifestInstance.version()));
819 return true;
820 });
821 return ret;
822 };
Yifan Hong9f78c182018-07-12 14:45:52 -0700823 return checkDeprecation(inManifest, error);
Yifan Hongf73ba512018-01-17 15:52:30 -0800824}
Yifan Hong3daec812017-02-27 18:49:11 -0800825
Yifan Hong9f78c182018-07-12 14:45:52 -0700826const std::unique_ptr<FileSystem>& VintfObject::getFileSystem() {
827 return mFileSystem;
828}
829
830const std::unique_ptr<PartitionMounter>& VintfObject::getPartitionMounter() {
831 return mPartitionMounter;
832}
833
834const std::unique_ptr<PropertyFetcher>& VintfObject::getPropertyFetcher() {
835 return mPropertyFetcher;
836}
837
838const std::unique_ptr<details::ObjectFactory<RuntimeInfo>>& VintfObject::getRuntimeInfoFactory() {
839 return mRuntimeInfoFactory;
Yifan Hong10d86222018-04-06 15:41:05 -0700840}
841
Yifan Hong3daec812017-02-27 18:49:11 -0800842} // namespace vintf
843} // namespace android