Tipos de dados

Dado um arquivo de interface HIDL, o backend Java HIDL gera interfaces Java, Stub e código proxy. Ele suporta todos os tipos escalares HIDL ([ u ] int { 8,16,32,64}_t, float, double, e enum s), bem como strings, interfaces, tipos safe_union, tipos struct e matrizes e vetores de suporte Tipos HIDL. O back-end Java HIDL NÃO suporta tipos de união ou tipos de fmq . O Android 11 adiciona suporte para os tipos de memory e handle .

Como o tempo de execução Java não suporta nativamente o conceito de inteiros não assinados, todos os tipos não assinados (e enums baseados neles) são tratados silenciosamente como seus equivalentes assinados, ou seja, uint32_t se torna um int na interface Java. Nenhuma conversão de valor é realizada; o implementador do lado Java deve usar os valores assinados como se não fossem assinados.

Enums

Enums não geram classes de enum Java, mas são traduzidas em classes internas contendo uma definição de constante estática para cada caso de enum. Se a classe enum derivar de alguma outra classe enum, ela herdará o tipo de armazenamento dessa classe. As enumerações baseadas em um tipo inteiro sem sinal são reescritas em seu equivalente com sinal. Como o tipo subjacente é primitivo, o valor padrão para campos/variáveis ​​enum é zero, mesmo quando não há enumerador zero.

Por exemplo, um SomeBaseEnum com um tipo de uint8_t :

enum SomeBaseEnum : uint8_t { foo = 3 };
enum SomeEnum : SomeBaseEnum {
    quux = 33,
    goober = 127
};

… torna-se:

public final class SomeBaseEnum { public static final byte foo = 3; }
public final class SomeEnum {
    public static final byte foo = 3;
    public static final byte quux = 33;
    public static final byte goober = 127;
}

E:

enum SomeEnum : uint8_t {
    FIRST_CASE = 10,
    SECOND_CASE = 192
};

… é reescrito como:

public final class SomeEnum {
    static public final byte FIRST_CASE  = 10;  // no change
    static public final byte SECOND_CASE = -64;
}

Cordas

String s em Java são utf-8 ou utf-16, mas são convertidas para utf-8 como o tipo HIDL comum quando transportadas. Além disso, uma String não deve ser nula quando passada para HIDL.

Alça e memória

O Android 11 apresenta suporte Java para tipos de handle e memory . Eles são traduzidos em android.os.NativeHandle e android.os.HidlMemory , respectivamente. Um identificador nulo é considerado válido, enquanto uma memória nula não é.

No código do servidor gerado, a memória recebida e os argumentos de manipulação são válidos apenas dentro do escopo da invocação do método. Se a implementação do servidor quiser estender seu tempo de vida, eles deverão ser duplicados usando seus respectivos métodos dup() . A instância retornada pode ser usada além da invocação do método e deve ser fechada corretamente quando terminar.

No código do cliente gerado, os identificadores e as instâncias de memória que são enviadas como argumentos de entrada do método chamado não precisam ser duplicados nem mantidos válidos após o retorno do método. No entanto, os identificadores e as instâncias de memória recebidos como argumentos de saída são automaticamente duplicados pelo código gerado automaticamente e devem ser fechados corretamente quando concluídos. Isso é verdade se esses argumentos de retorno aparecem como valores de retorno do método (no caso de valor de retorno único) ou usando o estilo de retorno de chamada síncrono (usado no caso de valor de retorno múltiplo).

Para obter mais informações sobre duplicação e fechamento, consulte a documentação das classes Java.

Matrizes e vetores

Matrizes são traduzidas em matrizes Java e vetores são traduzidos em ArrayList<T> onde T é o tipo de objeto apropriado, possivelmente agrupando tipos escalares como vec<int32_t> => ArrayList<Integer> ). Por exemplo:

takeAnArray(int32_t[3] array);
returnAVector() generates (vec<int32_t> result);

… torna-se:

void takeAnArray(int[] array);
ArrayList<Integer> returnAVector();

Estruturas

As estruturas são traduzidas em classes Java com layout semelhante. Por exemplo:

struct Bar {
 vec<bool> someBools;
};
struct Foo {
 int32_t a;
 int8_t b;
 float[10] c;
 Bar d;
};

… torna-se:

class Bar {
 public final ArrayList<Boolean> someBools = new ArrayList();
};
class Foo {
 public int a;
 public byte b;
 public final float[] c = new float[10];
 public final Bar d = new Bar();
}

Tipos declarados

Cada tipo de nível superior declarado em types.hal obtém seu próprio arquivo de saída .java (conforme exigido pelo Java). Por exemplo, o seguinte arquivo types.hal resulta na criação de dois arquivos extras (Foo.java e Bar.java):

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

A definição de Baz reside em uma classe interna estática de Bar (em Bar.java).