Linguagem AIDL

A linguagem AIDL é vagamente baseada na linguagem Java. Os arquivos especificam um contrato de interface de usuário e vários tipos de dados e constantes usados neste contrato.

Pacote

Cada arquivo AIDL começa com um pacote opcional que corresponde ao em vários back-ends. Uma declaração de pacote tem esta aparência:

    package my.package;

Semelhante ao Java, os arquivos AIDL devem estar em uma estrutura de pastas que corresponda . Os arquivos com o pacote my.package precisam estar na pasta my/package/.

Tipos

Em arquivos AIDL, há muitos lugares em que os tipos podem ser especificados. Para uma lista exata dos tipos compatíveis com a linguagem AIDL, consulte Tipos de back-ends da AIDL.

Anotações

Várias partes da linguagem AIDL oferecem suporte a anotações. Para uma lista de anotações e onde elas podem ser aplicadas, consulte Anotações AIDL.

Importações

Para usar tipos definidos em outras interfaces, primeiro você precisa adicionar dependências no sistema de build. Nos módulos Soong cc_* e java_*, em que os arquivos .aidl são usados. diretamente em srcs nos builds da plataforma Android, é possível adicionar diretórios usando o campo aidl: { include_dirs: ... }. Para importações que usam aidl_interface, consulte aqui.

Uma importação é assim:

    import some.package.Foo;  // explicit import

Ao importar um tipo no mesmo pacote, o pacote pode ser omitido. No entanto, a omissão do pacote pode levar a erros de importação ambíguos quando os tipos são especificados sem um pacote e colocados em um namespace global (geralmente todos os tipos deve receber namespaces):

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

Definir tipos

Os arquivos AIDL geralmente definem tipos que são usados como uma interface.

Interfaces

Confira um exemplo de interface AIDL:

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

Uma interface define um objeto com uma série de métodos. Os métodos podem ser oneway (oneway void doFoo()) ou síncrona. Se uma interface for definida como oneway (oneway interface ITeleport {...}), todos os métodos nele serão oneway implicitamente. Métodos de ida são enviados de forma assíncrona e não podem retornam um resultado. Métodos unidirecionais da mesma linha de execução para o mesmo binder também são executadas em série (embora potencialmente em diferentes linhas de execução). Para um discussão sobre como configurar linhas de execução, consulte Linha de execução de back-ends da AIDL de configuração.

Os métodos podem ter zero ou mais argumentos. Os argumentos para os métodos podem ser in, out ou inout. Para uma discussão sobre como isso afeta tipos de argumentos, ver Direcionalidade dos back-ends da AIDL.

Parcelables

Para uma descrição de como criar parcelables específicos de back-end, Back-ends AIDL personalizados parcelables.

O Android 10 e versões mais recentes são compatíveis com definições parcelable diretamente na AIDL. Esse tipo de parcelable é chamado de parcelable estruturado. Para mais informações sobre como a AIDL estruturada e estável está relacionada na compilador AIDL e nosso sistema de build, consulte Estruturado versus estável AIDL.

Exemplo:

    package my.package;

    import my.package.Boo;

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

União

O Android 12 e versões mais recentes oferecem suporte a declarações de união. Exemplo:

    package my.package;

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

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

Enumerações

O Android 11 e versões mais recentes oferecem suporte a declarações de enumeração. Exemplo:

    package my.package;

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

Declarações de tipo aninhadas

O Android 13 e versões mais recentes oferecem suporte a declarações de tipo aninhado. Exemplo:

    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

Interfaces AIDL personalizadas, parcelables e uniões também podem conter números inteiros e constantes de string, como:

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

Expressões constantes

Constantes da AIDL, tamanhos de matrizes e enumeradores podem ser especificados usando valores expressões idiomáticas. As expressões podem usar parênteses para aninhar operações. Constante valores de expressão podem ser usados com valores integrais ou flutuantes.

Os literais true e false representam valores booleanos. Valores com um ., mas sem um sufixo, como 3.8, são considerados valores duplos. Flutuante valores têm o sufixo f, como 2.4f. Um valor integral com o l ou O sufixo L indica um valor de 64 bits. Caso contrário, os valores das integrais menor tipo de assinatura que preserva o valor entre 8 bits (byte), 32 bits (int) e 64 bits (longo). Portanto, 256 é considerado um int, mas 255 + 1 estouro para ser o byte 0. Valores hexadecimais, como 0x3, são interpretados pela primeira vez como o menor tipo não assinado com preservação de valor entre 32 e 64 bits e reinterpretados como valores não assinados. Portanto, 0xffffffff tem o valor int. -1 A partir do Android 13, o sufixo u8 pode ser adicionadas a constantes, como 3u8, para representar um valor byte. Este sufixo é importante para que um cálculo, como 0xffu8 * 3, seja interpretado como -3 com o tipo byte, enquanto 0xff * 3 é 765 com o tipo int.

Os operadores compatíveis têm semânticas C++ e Java. Do menor para o com maior precedência, os operadores binários || && | ^ & == != < > <= >= << >> + - * / %: Os operadores unários são + - ! ~.