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 arrays e vetores de suportes Tipos HIDL. O backend Java HIDL NÃO suporta tipos de união ou tipos fmq . O Android 11 adiciona suporte para os tipos de memory e handle .

Como o Java runtime não suporta o conceito de inteiros não assinados nativamente, 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 no lado Java deve usar os valores assinados como se não fossem assinados.

Enums

As enumerações não geram classes de enumeração Java, mas são traduzidas em classes internas contendo uma definição de constante estática para cada caso de enumeração. 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 não assinado são reescritas em seu equivalente assinado. Como o tipo subjacente é um primitivo, o valor padrão para campos/variáveis ​​de enumeração é 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 convertidos em utf-8 como o tipo HIDL comum quando transportados. Além disso, um String não deve ser nulo quando passado para HIDL.

Manuseio e memória

O Android 11 apresenta suporte Java para os tipos 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 handle são válidos apenas dentro do escopo da invocação do método. Se a implementação do servidor quiser estender sua vida útil, eles devem 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 cliente gerado, handles e instâncias de memória que são enviadas como argumentos de entrada do método chamado não precisam ser duplicadas nem mantidas válidas após o retorno do método. No entanto, os identificadores e instâncias de memória que são recebidos como argumentos de saída são duplicados automaticamente pelo código gerado automaticamente e devem ser fechados corretamente quando terminarem. 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

Arrays são convertidos em arrays Java e vetores são convertidos em ArrayList<T> onde T é o tipo de objeto apropriado, possivelmente envolvendo 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 um 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 arquivo types.hal a seguir resulta na criação de dois arquivos extras (Foo.java e Bar.java):

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

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