Linguaggio AIDL

Il linguaggio AIDL è vagamente basato sul linguaggio Java. I file specificano di interfaccia e vari tipi di dati e costanti utilizzati in questo contratto.

Pacco

Ogni file AIDL inizia con un pacchetto facoltativo che corrisponde al pacchetto, nomi utente in vari backend. Una dichiarazione relativa al pacchetto è simile alla seguente:

    package my.package;

Analogamente a quanto avviene con Java, i file AIDL devono trovarsi in una struttura di cartelle corrispondente alla loro pacchetto. I file con il pacchetto my.package devono trovarsi nella cartella my/package/.

Tipi

Nei file AIDL esistono molte posizioni in cui è possibile specificare i tipi. Per un elenco esatto dei tipi supportati nella lingua AIDL, vedi Tipi di backend AIDL.

Annotazioni

Diverse parti del linguaggio AIDL supportano le annotazioni. Per un elenco di annotazioni e dove possono essere applicate, consulta Annotazioni AIDL.

Importazioni

Per utilizzare i tipi definiti in altre interfacce, devi prima aggiungere le dipendenze nella di un sistema di compilazione. Nei moduli presto cc_* e java_*, dove vengono utilizzati .aidl file direttamente in srcs nelle build della piattaforma Android, puoi aggiungere directory utilizzando il campo aidl: { include_dirs: ... }. Per le importazioni con aidl_interface, vedi qui.

Un'importazione ha il seguente aspetto:

    import some.package.Foo;  // explicit import

Quando si importa un tipo nello stesso pacchetto, il pacchetto può essere omesso. Tuttavia, l'omissione del pacchetto può causare errori di importazione ambigui quando i tipi vengono specificato senza un pacchetto e inserito nello spazio dei nomi globale (generalmente deve avere uno spazio dei nomi):

    import Foo;  // same as my.package.Foo

Definisci i tipi

I file AIDL in genere definiscono i tipi utilizzati come interfaccia.

Interfacce

Ecco un esempio di interfaccia AIDL:

    interface ITeleport {
        void teleport(Location baz, float speed);
        String getName();
    }

Un'interfaccia definisce un oggetto con una serie di metodi. I metodi possono essere oneway (oneway void doFoo()) o sincrona. Se un'interfaccia è definita come oneway (oneway interface ITeleport {...}), tutti i metodi al suo interno sono implicitamente oneway. I metodi unidirezionali vengono inviati in modo asincrono e non possono restituiscono un risultato. Anche i metodi unidirezionali dallo stesso thread allo stesso raccoglitore vengono eseguiti in modo seriale (anche se potenzialmente su thread diversi). Per un su come configurare i thread, vedi Thread di backend AIDL dei modelli.

I metodi possono avere zero o più argomenti. Gli argomenti dei metodi possono essere in, out o inout. Per discutere di come questo influisce sui tipi di argomenti, vedi Direzione dei backend AIDL.

Lotti da parte

Per una descrizione di come creare pacchetti di dati specifici per il backend, Backend AIDL personalizzati parcelables.

Android 10 e versioni successive supportano definizioni di pacchettizzabili direttamente in AIDL. Questo tipo di "parcelable" è chiamato "parcelable" strutturato. Per ulteriori informazioni su come l'AIDL strutturata e stabile sono correlate nel documento Per il compilatore AIDL e il nostro sistema di compilazione, consulta Struttura e confronto stabile AIDL.

Ad esempio:

    package my.package;

    import my.package.Boo;

    parcelable Baz {
        @utf8InCpp String name = "baz";
        Boo boo;
    }

Sindacati

Android 12 e versioni successive supportano le dichiarazioni dei sindacati. Ad esempio:

    package my.package;

    import my.package.FooSettings;
    import my.package.BarSettings;

    union Settings {
        FooSettings fooSettings;
        BarSettings barSettings;
        @utf8InCpp String str;
        int number;
    }

Enumerazionis

Dichiarazioni enum del supporto per Android 11 e versioni successive. Ad esempio:

    package my.package;

    enum Boo {
        A = 1 * 4,
        B = 3,
    }

Dichiarazioni dei tipi nidificati

Android 13 e versioni successive supportano le dichiarazioni dei tipi nidificate. Ad esempio:

    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
    }

Costanti

Anche le interfacce, i partizionabili e le unioni personalizzate AIDL possono contenere numeri interi e costante stringa, ad esempio:

    const @utf8InCpp String HAPPY = ":)";
    const String SAD = ":(";
    const byte BYTE_ME = 1;
    const int ANSWER = 6 * 7;

Espressioni costanti

Le costanti AIDL, le dimensioni degli array e gli enumeratori possono essere specificati utilizzando le espressioni regolari. Le espressioni possono utilizzare le parentesi per nidificare le operazioni. Costante i valori di espressione possono essere utilizzati con valori integrali o in virgola mobile.

I valori letterali true e false rappresentano valori booleani. Valori con . ma senza suffisso, ad esempio 3.8, sono considerati valori doppi. In virgola mobile valori hanno il suffisso f, ad esempio 2.4f. Un valore integrale con l o Il suffisso L indica un valore lungo a 64 bit. Altrimenti, i valori integrali ricevono il tipo firmato con protezione del valore più piccolo tra 8 bit (byte), 32 bit (int), e 64-bit (lunga). 256 è considerato un int, ma 255 + 1 gli overflow sono considerati byte 0. I valori esadecimali, come 0x3, vengono interpretati prima come il più piccolo tipo senza firma a garanzia di valore tra 32 bit e 64 bit e quindi reinterpretati come valori non firmati. Quindi, 0xffffffff ha il valore int -1. A partire da Android 13, il suffisso u8 può essere aggiunta a costanti, ad esempio 3u8, per rappresentare un valore byte. Questo suffisso è importante affinché un calcolo, ad esempio 0xffu8 * 3, venga interpretato come -3 con il tipo byte, mentre 0xff * 3 è 765 con il tipo int.

Gli operatori supportati hanno una semantica C++ e Java. In ordine dal più basso al la precedenza più alta, gli operatori binari || && | ^ & == != < > <= >= << >> + - * / %. Gli operatori unari sono + - ! ~.