Tipi di dati

Dato un file di interfaccia HIDL, il backend Java HIDL genera interfacce Java, Stub e il codice proxy. Supporta tutti i tipi HIDL scalari ([u]int{8,16,32,64}_t, float, double, e enum), così come stringhe, interfacce, tipi secure_union, struct nonché gli array e i vettori dei tipi HIDL supportati. Backend Java HIDL NON supporta i tipi di unione o i tipi fmq. Android 11 aggiunge il supporto per memory e Tipi di handle.

Poiché il runtime Java non supporta in modo nativo il concetto di numeri interi senza segno, tutti i tipi non firmati (e le enumerazioni basate su questi) vengono automaticamente trattati come equivalenti firmati, ad esempio uint32_t diventa int in l'interfaccia Java. Non viene eseguita alcuna conversione del valore. l'implementatore nella Il lato Java deve utilizzare i valori firmati come se fossero non firmati.

Enumerazionis

Le enum non generano classi enum Java, ma vengono tradotte in contenenti una definizione di costante statica per ogni caso enum. Se l'enumerazione deriva da un'altra classe enum, eredita il tipo di archiviazione di quella classe. Le enumerazioni basate su un tipo di valore intero senza segno vengono riscritte nel relativo equivalenti. Poiché il tipo sottostante è di tipo primitivo, il valore predefinito per enum è zero anche se non è presente un enumeratore zero.

Ad esempio, SomeBaseEnum con un tipo di uint8_t:

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

... diventa:

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

... viene riscritto come:

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

Stringhe

String in Java è utf-8 o utf-16 ma viene convertito in utf-8 come il comune tipo HIDL durante il trasporto. Inoltre, String non deve essere nullo se trasferito al livello HIDL.

Handle e memoria

Android 11 introduce il supporto Java per handle e Tipi di memory. Sono tradotti in android.os.NativeHandle e rispettivamente android.os.HidlMemory. Un handle null è considerato valido, mentre un handle null non lo è.

Nel codice server generato, gli argomenti relativi alla memoria e all'handle sono solo valido nell'ambito della chiamata al metodo. Se l'implementazione del server vuole estendere la propria , devono essere duplicati utilizzando i rispettivi metodi dup(). La l'istanza restituita può essere utilizzata oltre la chiamata del metodo e al termine deve essere chiusa correttamente con.

Nel codice client generato, gestisce e le istanze di memoria sent come argomenti di input del metodo chiamato non deve essere duplicato né conservato valida dopo che il metodo restituisce dei risultati. Tuttavia, gli handle e le istanze di memoria Ricevuto perché gli argomenti di output vengono duplicati automaticamente dal generato automaticamente e deve essere chiuso correttamente al termine dell'operazione. Questo vale sia per le parole chiave che vengono visualizzati come valori restituiti del metodo (nel caso del singolo valore restituito) o utilizzando il metodo stile di callback sincrono (utilizzato nel caso di più valori restituiti).

Per ulteriori informazioni sulla duplicazione e sulla chiusura, consulta la documentazione delle classi Java.

Array e vettori

Gli array vengono tradotti in array Java e i vettori in ArrayList<T>, dove T è il tipo di oggetto appropriato, possibilmente aggregare tipi scalari come vec<int32_t> => ArrayList<Integer>). Ad esempio:

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

... diventa:

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

Strutture

Le strutture vengono tradotte in classi Java con un layout simile. Per esempio:

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

... diventa:

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

Tipi dichiarati

Ogni tipo di primo livello dichiarato in types.hal riceve il proprio .java di output (come richiesto da Java). Ad esempio, Il file types.hal comporta la creazione di due file aggiuntivi (Foo.java e Bar.java):

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

La definizione di Baz risiede in una classe interna statica di bar (in Bar.java).