El lenguaje AIDL se basa en líneas generales en el lenguaje Java. Los archivos especifican un de interfaz de usuario y varios tipos de datos y constantes que se usan en este contrato.
Paquete
Cada archivo AIDL comienza con un paquete opcional que se corresponde con el y nombres en varios backends. Una declaración de paquete se ve de la siguiente manera:
package my.package;
Al igual que Java, los archivos AIDL deben estar en una estructura de carpetas que coincida con su
. Los archivos con el paquete my.package deben estar en la carpeta my/package/.
Tipos
En los archivos AIDL, hay muchos lugares en los que se pueden especificar tipos. Para obtener una lista exacta de los tipos admitidos en el lenguaje del AIDL, consulta Tipos de backends de AIDL.
Anotaciones
Varias partes del lenguaje de AIDL admiten anotaciones. Para obtener una lista de anotaciones y dónde se pueden aplicar, consulta Anotaciones de AIDL
Importaciones
Para usar tipos definidos en otras interfaces, primero debes agregar dependencias en el
de compilación. En los módulos cc_* y java_* de Soong, donde se usan archivos .aidl
directamente en srcs en compilaciones de la plataforma de Android, puedes agregar directorios
con el campo aidl: { include_dirs: ... }. Para las importaciones
aidl_interface, consulta
aquí.
Una importación se ve de la siguiente manera:
import some.package.Foo; // explicit import
Cuando importas un tipo en el mismo paquete, se puede omitir el paquete. Sin embargo, omitir el paquete puede generar errores de importación ambiguos cuando los tipos se especifica sin un paquete y se coloca en el espacio de nombres global (generalmente, todos los tipos debe tener espacios de nombres):
import Foo; // same as my.package.Foo
Definir tipos
Por lo general, los archivos AIDL definen tipos que se usan como interfaz.
Interfaces
Este es un ejemplo de interfaz de AIDL:
interface ITeleport {
void teleport(Location baz, float speed);
String getName();
}
Una interfaz define un objeto con una serie de métodos. Los métodos pueden ser
oneway (oneway void doFoo()) o síncrono. Si una interfaz se define como
oneway (oneway interface ITeleport {...}) y, luego, todos los métodos que contiene
oneway de forma implícita. Los métodos unidireccionales se despachan de forma asíncrona y no pueden
devolver un resultado. Los métodos unidireccionales del mismo subproceso al mismo Binder también
ejecutar en serie (aunque posiblemente en subprocesos diferentes). Para un
debate sobre cómo configurar subprocesos, consulta Subproceso de backends de AIDL
de la administración.
Los métodos pueden tener cero o más argumentos. Los argumentos de los métodos pueden ser
in, out o inout. Para analizar cómo esto afecta los tipos de argumentos,
ver
Orientación de backends de AIDL.
Objetos parcelables
Para ver una descripción de cómo crear objetos parcelables específicos del backend, consulta Backends de AIDL personalizados objetos parcelables.
Android 10 y las versiones posteriores admiten definiciones parcelables directamente en el AIDL. Este tipo de objeto parcelable se denomina elemento parcelable estructurado. Para obtener más información sobre cómo se relacionan el AIDL estructurado y estable en el Compilador de AIDL y nuestro sistema de compilación, consulta Estructurados versus estables AIDL
Por ejemplo:
package my.package;
import my.package.Boo;
parcelable Baz {
@utf8InCpp String name = "baz";
Boo boo;
}
Uniones
Android 12 y las versiones posteriores admiten declaraciones de unión. Por ejemplo:
package my.package;
import my.package.FooSettings;
import my.package.BarSettings;
union Settings {
FooSettings fooSettings;
BarSettings barSettings;
@utf8InCpp String str;
int number;
}
Enums
Android 11 y las versiones posteriores admiten declaraciones de enumeración. Por ejemplo:
package my.package;
enum Boo {
A = 1 * 4,
B = 3,
}
Declaraciones de tipos anidados
Android 13 y las versiones posteriores admiten declaraciones de tipos anidados. Por ejemplo:
package my.package;
import my.package.Baz;
interface IFoo {
void doFoo(Baz.Nested nested); // defined in my/package/Baz.aidl
void doBar(Bar bar); // defined below
parcelable Bar { ... } // nested type definition
}
Constantes
Las interfaces, los objetos parcelables y las uniones personalizados del AIDL también pueden contener valores y constantes de cadena, como
const @utf8InCpp String HAPPY = ":)";
const String SAD = ":(";
const byte BYTE_ME = 1;
const int ANSWER = 6 * 7;
Expresiones constantes
Las constantes del AIDL, los tamaños de los arrays y los enumeradores se pueden especificar usando la constante con expresiones regulares. Las expresiones pueden usar paréntesis para anidar operaciones. Constante los valores de expresión se pueden usar con valores integrales o flotantes.
Los literales true y false representan valores booleanos. Valores con ., pero
sin un sufijo, como 3.8, se consideran valores dobles. Número de punto flotante
los valores tienen el sufijo f, como 2.4f. Un valor integral con l o
El sufijo L indica un valor largo de 64 bits. De lo contrario, las integrales obtienen la
el tipo de firma más pequeño que preserva el valor entre 8 bits (byte), 32 bits (int),
y 64 bits (largo). Por lo tanto, 256 se considera un int, pero 255 + 1.
se desborda para ser el 0 de byte. Los valores hexadecimales, como 0x3, primero se interpretan.
como el tipo sin firma más pequeño que preserva el valor entre 32 y 64 bits
y luego se reinterpretan
como valores sin firma. Por lo tanto, 0xffffffff tiene el valor int.
-1 A partir de Android 13, el sufijo u8 se puede
Se agregan a las constantes, como 3u8, para representar un valor byte. Este sufijo es
importante para que un cálculo, como 0xffu8 * 3, se interprete como -3
con el tipo byte, mientras que 0xff * 3 es 765 con el tipo int.
Los operadores compatibles tienen semántica de C++ y Java. En orden de menor a
los operadores binarios de mayor precedencia,
|| && | ^ & == != < > <= >= << >> + - * / % Los operadores unarios son + - ! ~.