Tipos de dados

Dado um arquivo de interface HIDL, o back-end Java HIDL gera interfaces Java, stub e código de proxy. Oferece suporte a todos os tipos de HIDL escalares ([u]int{8,16,32,64}_t, float, double, e enums), bem como strings, interfaces, tipos safe_union, struct tipos e matrizes e vetores de tipos de HIDL compatíveis. Back-end HIDL do Java NÃO oferece suporte a tipos de união ou fmq. Android 11 adiciona suporte a memory e handle.

Como o ambiente de execução do Java não oferece suporte nativo ao conceito de números inteiros não assinados, todos os tipos não assinados (e tipos enumerados baseados neles) são tratados silenciosamente equivalentes assinados, ou seja, uint32_t se torna um int em a interface Java. Nenhuma conversão de valor é realizada. o implementador O lado do Java precisa usar os valores assinados como se não estivessem assinados.

Enumerações

Os tipos enumerados não geram classes de tipo enumerado Java, mas são convertidos em valores internos Classes que contêm uma definição de constante estática para cada caso de tipo enumerado. Se o tipo enumerado deriva de alguma outra classe de tipo enumerado, ela herda o tipo de armazenamento dessa classe. As enumerações com base em um tipo de número inteiro sem assinatura são reescritas no formato equivalentes. Como o tipo subjacente é um primitivo, o valor padrão do campos/variáveis de enumeração é zero, mesmo quando não há um enumerador de zero.

Por exemplo, uma SomeBaseEnum com um tipo de uint8_t:

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

... passa a ser:

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;
}

Strings

String em Java é utf-8 ou utf-16, mas é convertido para utf-8 como o tipo HIDL comum ao transportar. Além disso, String não podem ser nulos quando passados para o HIDL.

Alça e memória

O Android 11 introduz o suporte a Java para handle e memory. Elas estão traduzidas para o android.os.NativeHandle e android.os.HidlMemory, respectivamente. Um identificador nulo é considerado válido, e um valor nulo a memória não é.

No código server gerado, a memória recebida e os argumentos do identificador são apenas válidos no escopo da invocação do método. Se a implementação do servidor quiser estender as eles precisam ser duplicados usando os métodos dup() repetidos. A instância retornada pode ser usada além da invocação do método e deverá ser fechada corretamente quando concluída com

No código client gerado, os identificadores e as instâncias de memória que são sent como argumentos de entrada do método chamado não precisam ser duplicados nem mantidos válido após o retorno do método. Já os processadores e as instâncias de memória received porque os argumentos de saída são automaticamente duplicados pelo código gerado automaticamente e deve ser fechado corretamente quando terminar. Isso acontece se eles retornarem argumentos aparecem como valores de retorno do método (no caso do valor de retorno único) ou usam o método estilo de callback síncrono (usado no caso de vários valores de retorno).

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

Matrizes e vetores

As matrizes são convertidas em matrizes Java, e vetores são ArrayList<T>, em que T é o tipo de objeto apropriado, possivelmente encapsulando tipos escalares como vec<int32_t> => ArrayList<Integer>). Por exemplo:

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

... passa a ser:

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

Estruturas

As estruturas são convertidas 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;
};

... passa a ser:

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 recebe o próprio arquivo .java arquivo de saída (conforme exigido pelo Java). Por exemplo, os seguintes O 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).