A partir de 27 de março de 2025, recomendamos usar android-latest-release
em vez de aosp-main
para criar e contribuir com o AOSP. Para mais informações, consulte Mudanças no AOSP.
Objeto da interface do fornecedor
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Este documento descreve o design do objeto da interface do fornecedor
(objeto VINTF, na sigla em inglês), que agrega informações relevantes sobre um dispositivo e as disponibiliza
por meio de uma API pesquisável.
Design do objeto VINTF
Um objeto VINTF coleta algumas das informações necessárias diretamente do
dispositivo. Outros aspectos, como os manifestos, são descritos de forma estática no
XML.
Figura 1. Manifestos, matrizes de compatibilidade e informações coletadas no tempo de execução.
O design de objeto do VINTF fornece o seguinte para componentes de dispositivo e
framework:
Para o dispositivo |
Para o framework |
- Define um esquema para o componente estático (o
arquivo de
manifesto do dispositivo).
- Adiciona suporte ao tempo de build para definir o arquivo de manifesto do dispositivo para um determinado
dispositivo.
- Define a
API
consultável no momento da execução que recupera o arquivo de manifesto do dispositivo (junto com as outras
informações coletáveis no momento da execução) e as empacota no resultado da consulta.
|
|
O objeto VINTF precisa ser confiável e fornecer as mesmas informações completas
independentemente de quando o objeto é solicitado (consulte
Observações).
Manifestos e matrizes
A partir do Android 8.0, uma API de execução consulta o que está no dispositivo e envia essas
informações para o servidor de atualização over-the-air (OTA)
e outras partes interessadas (como o CTS
DeviceInfo
). Algumas informações são recuperadas no momento da execução e outras
são definidas de forma estática.
- O manifesto do dispositivo descreve o componente estático do que
o dispositivo pode fornecer ao framework.
- A matriz de compatibilidade do framework descreve o que o
framework do Android espera de um determinado dispositivo. A matriz é uma entidade estática
cuja composição é determinada manualmente durante o desenvolvimento da próxima versão
do framework do Android.
- O manifesto do framework descreve serviços de alto nível que o
framework pode fornecer ao dispositivo.
- A matriz de compatibilidade de dispositivos descreve os serviços que a
imagem do fornecedor exige da estrutura. A composição dele é determinada manualmente
durante o desenvolvimento do dispositivo.
Esses dois pares de manifestos e matrizes precisam ser reconciliados no momento da OTA para
garantir que um dispositivo possa receber atualizações de framework compatíveis com os
recursos dele. Em geral, um manifesto descreve o que é fornecido, e uma
matriz de compatibilidade descreve o que é necessário.
Esta seção inclui os seguintes detalhes sobre manifestos e matrizes:
- Manifestos definem
o manifesto do dispositivo, o manifesto do framework e o esquema do arquivo de manifesto.
- Matrizes
de compatibilidade define o esquema da matriz de compatibilidade.
- A página Ciclo de vida do FCM detalha
como as HALs HIDL são descontinuadas e removidas e como os arquivos do FCM são modificados para
refletir o status da versão da HAL.
- O artigo Desenvolvimento de DM descreve
como os fornecedores podem definir e declarar a versão do FCM de destino no manifesto
do dispositivo para novos dispositivos ou implementar novas versões do HAL e incrementar a
versão do FCM de destino ao atualizar a imagem do fornecedor para dispositivos antigos.
- Regras de correspondência
define as regras para uma correspondência bem-sucedida entre uma matriz de compatibilidade e um
manifesto.
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-07-27 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 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."]]