You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
172 lines
6.7 KiB
172 lines
6.7 KiB
/* |
|
* Copyright (C) 2017 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. |
|
*/ |
|
|
|
|
|
#ifndef ANDROID_VINTF_HAL_MANIFEST_H |
|
#define ANDROID_VINTF_HAL_MANIFEST_H |
|
|
|
#include <map> |
|
#include <string> |
|
#include <utils/Errors.h> |
|
#include <vector> |
|
|
|
#include "HalGroup.h" |
|
#include "ManifestHal.h" |
|
#include "MapValueIterator.h" |
|
#include "SchemaType.h" |
|
#include "Version.h" |
|
#include "Vndk.h" |
|
#include "XmlFileGroup.h" |
|
|
|
namespace android { |
|
namespace vintf { |
|
|
|
struct MatrixHal; |
|
struct CompatibilityMatrix; |
|
|
|
// A HalManifest is reported by the hardware and query-able from |
|
// framework code. This is the API for the framework. |
|
struct HalManifest : public HalGroup<ManifestHal>, public XmlFileGroup<ManifestXmlFile> { |
|
public: |
|
// manifest.version |
|
constexpr static Version kVersion{1, 0}; |
|
|
|
// Construct a device HAL manifest. |
|
HalManifest() : mType(SchemaType::DEVICE) {} |
|
|
|
// Given a component name (e.g. "android.hardware.camera"), |
|
// return getHal(name)->transport if the component exist and v exactly matches |
|
// one of the versions in that component, else EMPTY |
|
Transport getTransport(const std::string &name, const Version &v, |
|
const std::string &interfaceName, const std::string &instanceName) const; |
|
|
|
// Given a component name (e.g. "android.hardware.camera"), |
|
// return a list of version numbers that are supported by the hardware. |
|
// If the component is not found, empty list is returned. |
|
// If multiple matches, return a concatenation of version entries |
|
// (dupes removed) |
|
std::set<Version> getSupportedVersions(const std::string &name) const; |
|
|
|
// Given a component name (e.g. "android.hardware.camera") and an interface |
|
// name, return all instance names for that interface. |
|
// * If the component ("android.hardware.camera") does not exist, return empty list |
|
// * If the component ("android.hardware.camera") does exist, |
|
// * If the interface (ICamera) does not exist, return empty list |
|
// * Else return the list hal.interface.instance |
|
std::set<std::string> getInstances( |
|
const std::string &halName, const std::string &interfaceName) const; |
|
|
|
// Convenience method for checking if instanceName is in getInstances(halName, interfaceName) |
|
bool hasInstance(const std::string &halName, |
|
const std::string &interfaceName, const std::string &instanceName) const; |
|
|
|
// Return a list of component names that does NOT conform to |
|
// the given compatibility matrix. It contains components that are optional |
|
// for the framework if includeOptional = true. |
|
// Note: only HAL entries are checked. To check other entries as well, use |
|
// checkCompatibility. |
|
std::vector<std::string> checkIncompatibility(const CompatibilityMatrix &mat, |
|
bool includeOptional = true) const; |
|
|
|
// Check compatibility against a compatibility matrix. Considered compatible if |
|
// - framework manifest vs. device compat-mat |
|
// - checkIncompatibility for HALs returns only optional HALs |
|
// - one of manifest.vndk match compat-mat.vndk |
|
// - device manifest vs. framework compat-mat |
|
// - checkIncompatibility for HALs returns only optional HALs |
|
// - manifest.sepolicy.version match one of compat-mat.sepolicy.sepolicy-version |
|
bool checkCompatibility(const CompatibilityMatrix &mat, std::string *error = nullptr) const; |
|
|
|
// Generate a compatibility matrix such that checkCompatibility will return true. |
|
CompatibilityMatrix generateCompatibleMatrix() const; |
|
|
|
// Returns all component names. |
|
std::set<std::string> getHalNames() const; |
|
|
|
// Returns all component names and versions, e.g. |
|
// "android.hardware.camera.device@1.0", "android.hardware.camera.device@3.2", |
|
// "android.hardware.nfc@1.0"] |
|
std::set<std::string> getHalNamesAndVersions() const; |
|
|
|
// Given a component name (e.g. "android.hardware.camera"), |
|
// return a list of interface names of that component. |
|
// If the component is not found, empty list is returned. |
|
std::set<std::string> getInterfaceNames(const std::string &name) const; |
|
|
|
// Type of the manifest. FRAMEWORK or DEVICE. |
|
SchemaType type() const; |
|
|
|
// Get all hals with the name |
|
std::vector<const ManifestHal *> getHals(const std::string &name) const; |
|
std::vector<ManifestHal *> getHals(const std::string &name); |
|
|
|
// device.mSepolicyVersion. Assume type == device. |
|
// Abort if type != device. |
|
const Version &sepolicyVersion() const; |
|
|
|
// framework.mVndks. Assume type == framework. |
|
// Abort if type != framework. |
|
const std::vector<Vndk> &vndks() const; |
|
|
|
// If the corresponding <xmlfile> with the given version exists, |
|
// - Return the overridden <path> if it is present, |
|
// - otherwise the default value: /{system,vendor}/etc/<name>_V<major>_<minor>.xml |
|
// Otherwise if the <xmlfile> entry does not exist, "" is returned. |
|
std::string getXmlFilePath(const std::string& xmlFileName, const Version& version) const; |
|
|
|
protected: |
|
// Check before add() |
|
bool shouldAdd(const ManifestHal& toAdd) const override; |
|
bool shouldAddXmlFile(const ManifestXmlFile& toAdd) const override; |
|
|
|
private: |
|
friend struct HalManifestConverter; |
|
friend class VintfObject; |
|
friend class AssembleVintf; |
|
friend struct LibVintfTest; |
|
friend std::string dump(const HalManifest &vm); |
|
friend bool operator==(const HalManifest &lft, const HalManifest &rgt); |
|
|
|
// Return an iterable to all ManifestHal objects. Call it as follows: |
|
// for (const ManifestHal &e : vm.getHals()) { } |
|
ConstMultiMapValueIterable<std::string, ManifestHal> getHals() const; |
|
|
|
status_t fetchAllInformation(const std::string &path); |
|
|
|
// Check if all instances in matrixHal is supported in this manifest. |
|
bool isCompatible(const MatrixHal& matrixHal) const; |
|
|
|
std::vector<std::string> checkIncompatibleXmlFiles(const CompatibilityMatrix& mat, |
|
bool includeOptional = true) const; |
|
|
|
SchemaType mType; |
|
|
|
// entries for device hal manifest only |
|
struct { |
|
Version mSepolicyVersion; |
|
} device; |
|
|
|
// entries for framework hal manifest only |
|
struct { |
|
std::vector<Vndk> mVndks; |
|
} framework; |
|
}; |
|
|
|
|
|
} // namespace vintf |
|
} // namespace android |
|
|
|
#endif // ANDROID_VINTF_HAL_MANIFEST_H
|
|
|