À partir du 27 mars 2025, nous vous recommandons d'utiliser android-latest-release
au lieu de aosp-main
pour créer et contribuer à AOSP. Pour en savoir plus, consultez la section Modifications apportées à AOSP.
Objet de l'interface du fournisseur
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Ce document décrit la conception de l'objet interface fournisseur (objet VINTF), qui agrège les informations pertinentes sur un appareil et les met à disposition via une API interrogable.
Conception de l'objet VINTF
Un objet VINTF rassemble certaines des informations dont il a besoin directement à partir de l'appareil. D'autres aspects, tels que les fichiers manifestes, sont décrits de manière statique en XML.
Figure 1 : Les fichiers manifestes, les matrices de compatibilité et les informations collectables au moment de l'exécution.
La conception d'objets VINTF fournit les éléments suivants pour les composants de l'appareil et du framework:
Pour l'appareil |
Pour le framework |
- Définit un schéma pour le composant statique (le fichier manifeste de l'appareil).
- Ajout de la prise en charge du temps de compilation pour définir le fichier manifeste de l'appareil pour un appareil donné.
- Définit l'API interrogable au moment de l'exécution, qui récupère le fichier manifeste de l'appareil (avec les autres informations collectables au moment de l'exécution) et les regroupe dans le résultat de la requête.
|
- Définit un schéma pour le composant statique (le fichier manifeste du framework).
- Définit l'API interrogable au moment de l'exécution, qui récupère le fichier manifeste du framework et le met en package dans le résultat de la requête.
|
L'objet VINTF doit être fiable et fournir les mêmes informations complètes, quel que soit le moment où l'objet est demandé (voir la section Avertissements).
Fichiers manifestes et matrices
Depuis Android 8.0, une API d'exécution interroge ce qui se trouve sur l'appareil et envoie ces informations au serveur de mise à jour Over-the-Air (OTA) et aux autres parties intéressées (telles que CTS DeviceInfo
). Certaines informations sont récupérées au moment de l'exécution et d'autres sont définies de manière statique.
- Le fichier manifeste de l'appareil décrit le composant statique de ce que l'appareil peut fournir au framework.
- La matrice de compatibilité du framework décrit ce que le framework Android attend d'un appareil donné. La matrice est une entité statique dont la composition est déterminée manuellement lors du développement de la prochaine version du framework Android.
- Le fichier manifeste du framework décrit les services de haut niveau que le framework peut fournir à l'appareil.
- La matrice de compatibilité des appareils décrit les services que l'image du fournisseur exige du framework. Sa composition est déterminée manuellement lors du développement de l'appareil.
Ces deux paires de fichiers manifestes et de matrices doivent être réconciliées au moment de la mise à jour OTA pour s'assurer qu'un appareil peut recevoir des mises à jour de framework compatibles avec ses fonctionnalités. En général, un fichier manifeste décrit ce qui est fourni, et une matrice de compatibilité décrit ce qui est requis.
Cette section inclut les informations suivantes sur les fichiers manifestes et les matrices:
- Manifestes définit le fichier manifeste de l'appareil, le fichier manifeste du framework et le schéma du fichier manifeste.
- Matrices de compatibilité définit le schéma de la matrice de compatibilité.
- Le cycle de vie de FCM explique comment les HAL HIDL sont obsolètes et supprimées, et comment les fichiers FCM sont modifiés pour refléter l'état de la version HAL.
- Développement DM décrit comment les fournisseurs peuvent définir et déclarer la version FCM cible dans le fichier manifeste de l'appareil pour les nouveaux appareils, ou implémenter de nouvelles versions HAL et incrémenter la version FCM cible lors de la mise à niveau de l'image du fournisseur pour les anciens appareils.
- Matching Rules (Règles de correspondance) définit les règles d'une correspondance réussie entre une matrice de compatibilité et un fichier manifeste.
Le contenu et les exemples de code de cette page sont soumis aux licences décrites dans la Licence de contenu. Java et OpenJDK sont des marques ou des marques déposées d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/07/27 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Il n'y a pas l'information dont j'ai besoin","missingTheInformationINeed","thumb-down"],["Trop compliqué/Trop d'étapes","tooComplicatedTooManySteps","thumb-down"],["Obsolète","outOfDate","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Mauvais exemple/Erreur de code","samplesCodeIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 2025/07/27 (UTC)."],[],[],null,["# Vendor interface object\n\nThis document describes the design of the *vendor interface object*\n(VINTF object), which aggregates relevant information about a device and makes\nthat information available through a *queryable API*.\n\nVINTF object design\n-------------------\n\nA VINTF object gathers some of the information it needs directly from the\ndevice. Other aspects, such as the manifests, are described statically in\nXML.\n\n**Figure 1.** Manifests, compatibility matrixes, and runtime-collectible information.\n\nVINTF object design provides the following for device and framework\ncomponents:\n\n| For the Device | For the Framework |\n|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| - Defines a schema for the static component (the [device manifest file](/docs/core/architecture/vintf/objects#device-manifest-file)). - Adds build time support for defining the device manifest file for a given device. - Defines the [queryable API](/docs/core/architecture/vintf/objects#queryable-api) at runtime that retrieves the device manifest file (along with the other runtime-collectible information) and packages them into the query result. | - Defines a schema for the static component (the [framework manifest file](/docs/core/architecture/vintf/objects#framework-manifest-file)). - Defines the [queryable API](/docs/core/architecture/vintf/objects#queryable-api) at runtime that retrieves the framework manifest file and packages it into the query result. |\n\nThe VINTF object must be reliable and provide the same complete information\nregardless of when the object is requested (see\n[Caveats](/docs/core/architecture/vintf/resources#caveats)).\n\nManifests and matrixes\n----------------------\n\nAs of Android 8.0, a runtime API queries what is on the device and sends that\ninformation to the [Over-the-Air (OTA)](/docs/core/ota)\nupdate server and other interested parties (such as CTS\n`DeviceInfo`). Some information is retrieved at runtime and some of\nit is statically-defined.\n\n- The **device manifest** describes the static component of what the device can provide to the framework.\n- The **framework compatibility matrix** describes what the Android framework expects from a given device. The matrix is a static entity whose composition is determined manually during development of the next release of the Android framework.\n- The **framework manifest** describes high-level services the framework can provide to the device.\n- The **device compatibility matrix** describes the services the vendor image requires of the framework. Its composition is determined manually during the development of the device.\n\nThese two pairs of manifests and matrixes must be reconciled at OTA time to\nensure a device can get framework updates that are compatible with the device's\ncapabilities. In general, a *manifest* describes what is provided and a\n*compatibility matrix* describes what is required.\n\nThis section includes the following details on manifests and matrixes:\n\n- [Manifests](/docs/core/architecture/vintf/objects) defines the device manifest, framework manifest, and manifest file schema.\n- [Compatibility\n Matrixes](/docs/core/architecture/vintf/comp-matrices) defines the schema for the compatibility matrix.\n- [FCM Lifecycle](/docs/core/architecture/vintf/fcm) details how HIDL HALs are deprecated and removed and how FCM files are modifed to reflect the status of the HAL Version.\n- [DM Development](/docs/core/architecture/vintf/dm) describes how vendors can define and declare the Target FCM Version in the device manifest for new devices or implement new HAL versions and increment the Target FCM Version when upgrading the vendor image for old devices.\n- [Matching Rules](/docs/core/architecture/vintf/match-rules) defines the rules for a successful match between a compatibility matrix and a manifest."]]