Google se compromete a avanzar en la equidad racial para las comunidades negras. Ver cómo.
Se usó la API de Cloud Translation para traducir esta página.
Switch to English

HIDL

HAL lenguaje de definición de interfaz o HIDL (pronunciado "ocultar-l") es un lenguaje de descripción de interfaz (IDL) para especificar la interfaz entre un HAL y sus usuarios. Permite especificar y tipos de llamadas a métodos, recogidos en las interfaces y paquetes. En términos más generales, HIDL es un sistema para la comunicación entre bases de código que pueden ser compilados de forma independiente.

HIDL está destinado a ser utilizado para la comunicación entre procesos (IPC). La comunicación entre procesos se conoce como revestidas con un aglutinante . Para las bibliotecas que deben estar vinculados a un proceso, un modo de pasarela también está disponible (no soportado en Java).

HIDL especifica estructuras de datos y firmas de método, organizados en las interfaces (similar a una clase) que se recogen en paquetes. La sintaxis de HIDL le resultará familiar a los programadores de C ++ y Java, aunque con un conjunto diferente de palabras clave. HIDL también utiliza anotaciones al estilo de Java.

diseño HIDL

El objetivo de HIDL es que el marco se puede sustituir sin tener que reconstruir HAL. HAL serán construidas por los proveedores o fabricantes de SOC y poner en un /vendor partición en el dispositivo, lo que permite el marco, en su propia partición, para ser reemplazada con una OTA sin recompilar los HAL.

diseño HIDL equilibra las siguientes preocupaciones:

  • Interoperabilidad. Crear interfaces de forma fiable interoperables entre los procesos que pueden ser compilados con varias arquitecturas, cadenas de herramientas y configuraciones de construcción. interfaces de HIDL están versionadas y no se pueden cambiar después de que se publiquen.
  • Eficiencia. HIDL trata de minimizar el número de operaciones de copia. los datos se entregan a código C ++ en las estructuras de datos de disposición estándar de C ++ que se puede utilizar sin desembalaje HIDL-definido. HIDL también proporciona interfaces de memoria compartida y, como RPCs son inherentemente algo lento, soportes HIDL dos formas de transferencia de datos sin necesidad de utilizar una llamada RPC: memoria compartida y un mensaje Fast Queue (FMQ).
  • Intuitiva. HIDL evita espinosos problemas de la propiedad de memoria utilizando sólo in parámetros para RPC (véase la interfaz de Android Definition Language (AIDL) ); valores que no pueden ser devueltos de manera eficiente de métodos se devuelven a través de funciones de devolución de llamada. Ninguno pasa los datos en HIDL para la transferencia ni la recepción de datos desde HIDL cambia la propiedad de los datos, la propiedad permanece siempre con la función de llamada. Los datos tienen que persisten sólo durante la duración de la función de llamada y puede ser destruido inmediatamente después de los llamados devuelve la función.

Uso del modo de pasarela

Para actualizar los dispositivos que ejecutan versiones anteriores de Android para Android O, se puede envolver ambos HAL convencionales (y de legado) en una nueva interfaz HIDL que sirve a la HAL en los modos con un aglutinante y del mismo proceso (paso a través). Esta envoltura es transparente tanto para el HAL y el marco de Android.

Modo de transferencia directa está disponible sólo para los clientes y las implementaciones de C ++. Dispositivos que ejecutan versiones anteriores de Android no tienen HAL escritos en Java, por lo que HAL Java están revestidas con un aglutinante inherentemente.

Cuando un .hal se compila archivo, hidl-gen produce un archivo de cabecera passthrough adicional BsFoo.h además de las cabeceras utilizadas para la comunicación aglutinante; Esto funciona Define las cabeceras a ser dlopen ed. Como HAL de paso a través ejecutan en el mismo proceso en el que se les llama, en la mayoría de los casos passthrough métodos son invocados por llamada de función directa (mismo hilo). oneway métodos ejecutan en su propio hilo, ya que no tienen la intención de esperar a que el HAL para procesarlos (Esto significa que cualquier HAL que los usos oneway métodos en modo de traspaso debe ser seguro para subprocesos).

Dado un IFoo.hal , BsFoo.h envuelve los métodos generado HIDL-para proporcionar características adicionales (como hacer oneway transacciones ejecutar en otro hilo). Este archivo es similar a BpFoo.h , sin embargo, en lugar de transmitir llamadas IPC utilizando aglutinante, las funciones deseadas se invocan directamente. Implementaciones futuras de HAL pueden proporcionar múltiples implementaciones, tales como FooFast HAL y un HAL FooAccurate. En tales casos, un archivo para cada aplicación adicional sería creado (por ejemplo, PTFooFast.cpp y PTFooAccurate.cpp ).

Binderizing pasarela HAL

Puede binderize implementaciones HAL compatibles con el modo de paso a través. Dado un HAL interfaz abcd@MN::IFoo , dos paquetes se crean:

  • abcd@MN::IFoo-impl . Contiene la aplicación de la HAL y expone funcionan IFoo* HIDL_FETCH_IFoo(const char* name) . En los dispositivos de legado, este paquete es dlopen ed y la implementación se crea una instancia utilizando HIDL_FETCH_IFoo . Puede generar el código base usando hidl-gen y -Lc++-impl y -Landroidbp-impl .
  • abcd@MN::IFoo-service . Abre el HAL y registros pasarela como un servicio con un aglutinante, lo que permite la misma aplicación HAL para ser utilizado tanto como pasarela y revestidas con un aglutinante.

Dado el tipo IFoo , puede llamar sp<IFoo> IFoo::getService(string name, bool getStub) para obtener acceso a una instancia de IFoo . Si getStub es cierto, getService intentos para abrir el HAL sólo en el modo de paso a través. Si getStub es falsa, getService intentos de encontrar un servicio con un aglutinante; si eso no funciona, entonces se trata de encontrar el servicio de transferencia. El getStub parámetro nunca debe ser usado excepto en defaultPassthroughServiceImplementation . (Dispositivos de lanzamiento con Android O están revestidas con un aglutinante totalmente dispositivos, por lo que la apertura de un servicio en el modo de traspaso no está permitida.)

gramática HIDL

Por diseño, el lenguaje HIDL es similar a C (pero no utiliza el preprocesador C). Todo puntuacion no se describe a continuación (aparte del uso evidente de = y | ) es parte de la gramática.

Nota: Para obtener más detalles sobre el estilo de código HIDL, consulte la Guía de Estilo de Código .

  • /** */ indica un comentario documentación. Estos sólo se pueden aplicar a tipo, método, campo, y las declaraciones valor de enumeración.
  • /* */ Indica un comentario de varias líneas.
  • // indica un comentario al final de la línea. Aparte de // , saltos de línea son los mismos que cualquier otro espacio en blanco.
  • En el ejemplo de la gramática a continuación, el texto de // hasta el final de la línea no es parte de la gramática sino que es un comentario sobre la gramática.
  • [empty] significa que el término puede estar vacío.
  • ? siguiente un medio literales o plazo es opcional.
  • ... indica la secuencia que contiene cero o más elementos, con la separación de puntuacion como se indica. No hay argumentos variadic en HIDL.
  • Las comas separan elementos de la secuencia.
  • Punto y coma terminan cada elemento, incluyendo el último elemento.
  • MAYÚSCULAS es un no terminal.
  • italics es una familia de contadores tales como integer o identifier (reglas C de análisis estándar).
  • constexpr es una expresión constante estilo C (tal como 1 + 1 y 1L << 3 ).
  • import_name es un nombre de paquete o interfaz, calificado como se describe en HIDL de versiones .
  • Minúsculas words son símbolos literales.

Ejemplo:

ROOT =
    PACKAGE IMPORTS PREAMBLE { ITEM ITEM ... }  // not for types.hal
  | PACKAGE IMPORTS ITEM ITEM...  // only for types.hal; no method definitions

ITEM =
    ANNOTATIONS? oneway? identifier(FIELD, FIELD ...) GENERATES?;
  |  safe_union identifier { UFIELD; UFIELD; ...};
  |  struct identifier { SFIELD; SFIELD; ...};  // Note - no forward declarations
  |  union identifier { UFIELD; UFIELD; ...};
  |  enum identifier: TYPE { ENUM_ENTRY, ENUM_ENTRY ... }; // TYPE = enum or scalar
  |  typedef TYPE identifier;

VERSION = integer.integer;

PACKAGE = package android.hardware.identifier[.identifier[...]]@VERSION;

PREAMBLE = interface identifier EXTENDS

EXTENDS = <empty> | extends import_name  // must be interface, not package

GENERATES = generates (FIELD, FIELD ...)

// allows the Binder interface to be used as a type
// (similar to typedef'ing the final identifier)
IMPORTS =
   [empty]
  |  IMPORTS import import_name;

TYPE =
  uint8_t | int8_t | uint16_t | int16_t | uint32_t | int32_t | uint64_t | int64_t |
 float | double | bool | string
|  identifier  // must be defined as a typedef, struct, union, enum or import
               // including those defined later in the file
|  memory
|  pointer
|  vec<TYPE>
|  bitfield<TYPE>  // TYPE is user-defined enum
|  fmq_sync<TYPE>
|  fmq_unsync<TYPE>
|  TYPE[SIZE]

FIELD =
   TYPE identifier

UFIELD =
   TYPE identifier
  |  safe_union identifier { FIELD; FIELD; ...} identifier;
  |  struct identifier { FIELD; FIELD; ...} identifier;
  |  union identifier { FIELD; FIELD; ...} identifier;

SFIELD =
   TYPE identifier
  |  safe_union identifier { FIELD; FIELD; ...};
  |  struct identifier { FIELD; FIELD; ...};
  |  union identifier { FIELD; FIELD; ...};
  |  safe_union identifier { FIELD; FIELD; ...} identifier;
  |  struct identifier { FIELD; FIELD; ...} identifier;
  |  union identifier { FIELD; FIELD; ...} identifier;

SIZE =  // Must be greater than zero
     constexpr

ANNOTATIONS =
     [empty]
  |  ANNOTATIONS ANNOTATION

ANNOTATION =
  |  @identifier
  |  @identifier(VALUE)
  |  @identifier(ANNO_ENTRY, ANNO_ENTRY  ...)

ANNO_ENTRY =
     identifier=VALUE

VALUE =
     "any text including \" and other escapes"
  |  constexpr
  |  {VALUE, VALUE ...}  // only in annotations

ENUM_ENTRY =
     identifier
  |  identifier = constexpr

Terminología

En esta sección se utilizan los siguientes términos relacionados HIDL-:

revestidas con un aglutinante Indica HIDL está siendo utilizado para llamadas a procedimiento remoto entre los procesos, implementado sobre un aglutinante como mecanismo. Ver también passthrough.
devolución de llamada, asíncrono Interface servida por un usuario HAL, se pasa a la HAL (a través de un método HIDL), y llamado por el HAL para devolver datos en cualquier momento.
devolución de llamada, sincrónica Devuelve datos de implementación del método HIDL de un servidor al cliente. Sin uso de métodos que devuelven un solo valor simple vacío o una.
cliente Proceso que llama a los métodos de una interfaz en particular. A HAL o proceso del marco pueden ser un cliente de una interfaz y un servidor de otro. Ver también passthrough.
se extiende Indica una interfaz que añade métodos y / o tipos de otra interfaz. Una interfaz puede extender sólo a otra interfaz. Puede ser utilizado para un incremento de versión menor en el mismo nombre de paquete o de un nuevo paquete (por ejemplo, un proveedor de extensión) basarse en un paquete más.
genera Indica un método de interfaz que los valores devuelve al cliente. Para volver un valor no primitivo, o más de un valor, se genera una función de devolución de llamada síncrona.
interfaz Colección de métodos y tipos. Traducido en una clase en C ++ o Java. Todos los métodos en una interfaz se llaman en la misma dirección: un proceso de cliente invoca métodos implementados por un proceso de servidor.
de una sola mano Cuando se aplica a un método HIDL, indica el método devuelve ningún valor y no bloquea.
paquete Colección de interfaces y tipos de datos que comparten una versión.
pasar por Modo de HIDL en el que el servidor es una biblioteca compartida, dlopen ed por el cliente. En el modo de paso a través, cliente y servidor son el mismo proceso, pero bases de código separadas. Se usa sólo para traer bases de código de legado en el modelo HIDL. Ver también revestidas con un aglutinante.
servidor Proceso que implementa los métodos de una interfaz. Ver también passthrough.
transporte infraestructura HIDL que mueve datos entre el servidor y el cliente.
versión Versión de un paquete. Consta de dos números enteros, mayor y menor. incrementos de versión secundaria pueden añadir (pero no cambiar) tipos y métodos.