Le langage AIDL est vaguement basé sur le langage Java. Les fichiers spécifient un contrat d'interface et différents types de données et constantes utilisés dans ce contrat.
Package
Chaque fichier AIDL commence par un package facultatif correspondant au package dans différents backends. Une déclaration de package se présente comme suit:
package my.package;
Comme pour Java, les fichiers AIDL doivent se trouver dans une structure de dossiers correspondant à leur
d'un package. Les fichiers avec le package my.package
doivent se trouver dans le dossier my/package/
.
Types
Dans les fichiers AIDL, les types peuvent être spécifiés à de nombreux endroits. Pour obtenir la liste exacte des types compatibles avec le langage AIDL, consultez Types de backends AIDL
Annotations
Plusieurs parties des annotations de prise en charge du langage AIDL Pour obtenir une liste et les endroits où elles peuvent être appliquées, consultez Annotations AIDL
Importations
Pour utiliser des types définis dans d'autres interfaces, vous devez d'abord ajouter des dépendances dans le
du système de compilation. Dans les modules Soong cc_*
et java_*
, où des fichiers .aidl
sont utilisés
directement sous srcs
dans les builds de la plate-forme Android, vous pouvez ajouter des répertoires
à l'aide du champ aidl: { include_dirs: ... }
. Pour les importations avec
aidl_interface
, consultez
cliquez ici.
Une importation se présente comme suit:
import some.package.Foo; // explicit import
Lorsque vous importez un type dans le même package, le package peut être omis. Toutefois, l'omission du package peut entraîner des erreurs d'importation ambiguës lorsque les types sont spécifié sans package et placé dans l'espace de noms global (généralement tous les types doit être un espace de noms):
import Foo; // same as my.package.Foo
Définir les types
Les fichiers AIDL définissent généralement des types qui sont utilisés comme une interface.
Interfaces
Voici un exemple d'interface AIDL:
interface ITeleport {
void teleport(Location baz, float speed);
String getName();
}
Une interface définit un objet avec une série de méthodes. Les méthodes peuvent être
oneway
(oneway void doFoo()
) ou synchrone. Si une interface est définie comme
oneway
(oneway interface ITeleport {...}
), toutes les méthodes qu'il contient sont
implicitement oneway
. Les méthodes à sens unique sont envoyées de manière asynchrone et ne peuvent pas
renvoyer un résultat. Les méthodes unidirectionnelles du même thread vers la même liaison
s'exécutent en série (mais potentiellement sur des threads différents). Pour une
pour en savoir plus sur la configuration des threads, consultez la section Thread de backends AIDL
gestion de la sécurité.
Les méthodes peuvent avoir zéro ou plusieurs arguments. Les arguments des méthodes peuvent être
in
, out
ou inout
. Pour en savoir plus sur la façon dont cela affecte les types d'arguments,
voir
Orientation des backends AIDL
Éléments Parcelables
Pour savoir comment créer des parcelables spécifiques au backend, Backends AIDL personnalisés parcelables.
Android 10 ou version ultérieure est compatible avec les définitions parcelables directement dans AIDL. Ce type d'élément morcelé est appelé "parcelable structuré". Pour en savoir plus sur la façon dont AIDL est structuré et stable, consultez le le compilateur AIDL et notre système de compilation, consultez la section Structuré ou stable ; AIDL
Exemple :
package my.package;
import my.package.Boo;
parcelable Baz {
@utf8InCpp String name = "baz";
Boo boo;
}
Union
Android 12 et versions ultérieures sont compatibles avec les déclarations d'union. Exemple :
package my.package;
import my.package.FooSettings;
import my.package.BarSettings;
union Settings {
FooSettings fooSettings;
BarSettings barSettings;
@utf8InCpp String str;
int number;
}
Énumérations
Android 11 ou version ultérieure est compatible avec les déclarations d'énumération. Exemple :
package my.package;
enum Boo {
A = 1 * 4,
B = 3,
}
Déclarations des types imbriqués
Android 13 et versions ultérieures sont compatibles avec les déclarations de types imbriqués. Exemple :
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
Les interfaces AIDL personnalisées, les parcelables et les unions peuvent également contenir des nombres entiers et les constantes de chaîne, telles que:
const @utf8InCpp String HAPPY = ":)";
const String SAD = ":(";
const byte BYTE_ME = 1;
const int ANSWER = 6 * 7;
Expressions constantes
Les constantes AIDL, les tailles de tableaux et les énumérateurs peuvent être spécifiés à l'aide de constantes . Les expressions peuvent utiliser des parenthèses pour imbriquer des opérations. Constante les valeurs d'expression peuvent être utilisées avec des valeurs intégrales ou flottantes.
Les littéraux true
et false
représentent des valeurs booléennes. Les valeurs avec un .
, mais
sans suffixe (par exemple, 3.8
) sont considérées comme des valeurs doubles. Nombre à virgule flottante
ont le suffixe f
, par exemple 2.4f
. Une valeur intégrale avec l
ou
Le suffixe L
indique une valeur de 64 bits. Sinon, les valeurs intégrales obtiennent
le plus petit type signé préservant la valeur entre 8 bits (octet), 32 bits (int)
et 64 bits (long). 256
est donc considéré comme int
, mais 255 + 1
.
déborde pour devenir le 0
byte
. Les valeurs hexadécimales, telles que 0x3
, sont d'abord interprétées
comme le plus petit type non signé préservant la valeur entre 32 bits et 64 bits
puis réinterprétées comme des valeurs non signées. Ainsi, 0xffffffff
a la valeur int
.
-1
À partir d'Android 13, le suffixe u8
peut être
ajoutée à des constantes, telles que 3u8
, pour représenter une valeur byte
. Ce suffixe est
important pour qu'un calcul, tel que 0xffu8 * 3
, soit interprété comme -3
.
de type byte
, tandis que 0xff * 3
est 765
de type int
.
Les opérateurs compatibles ont une sémantique C++ et Java. Dans l'ordre, du plus bas au plus
priorité la plus élevée, les opérateurs binaires sont
|| && | ^ & == != < > <= >= << >> + - * / %
Les opérateurs unaires sont + - ! ~
.