Tipi di dati

Dato un file di interfaccia HIDL, il backend Java HIDL genera interfacce Java, Stub e codice proxy. Supporta tutti i tipi HIDL scalari ([ u ] int { 8,16,32,64}_t, float, double, ed enum s), nonché stringhe, interfacce, tipi safe_union, tipi struct e array e vettori di formati supportati Tipi HIDL. Il backend Java HIDL NON supporta i tipi union o fmq . Android 11 aggiunge il supporto per la memory e i tipi di handle .

Poiché Java runtime non supporta nativamente il concetto di interi senza segno, tutti i tipi senza segno (e le enumerazioni basate su di essi) vengono trattati silenziosamente come i loro equivalenti con segno, ovvero uint32_t diventa un int nell'interfaccia Java. Non viene eseguita alcuna conversione del valore; l'implementatore sul lato Java deve utilizzare i valori con segno come se non fossero firmati.

Enumerazioni

Le enumerazioni non generano classi di enumerazione Java ma vengono invece tradotte in classi interne contenenti una definizione costante statica per ogni caso di enumerazione. Se la classe enum deriva da un'altra classe enum, eredita il tipo di archiviazione di quella classe. Le enumerazioni basate su un tipo intero senza segno vengono riscritte nel loro equivalente con segno. Poiché il tipo sottostante è una primitiva, il valore predefinito per i campi/variabili enum è zero anche quando non è presente un enumeratore zero.

Ad esempio, un 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 sono utf-8 o utf-16 ma vengono convertite in utf-8 come tipo HIDL comune quando vengono trasportate. Inoltre, una String non deve essere nulla quando viene passata a HIDL.

Maniglia e memoria

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

Nel codice server generato, la memoria ricevuta e gli argomenti di handle sono validi solo nell'ambito della chiamata del metodo. Se l'implementazione del server vuole prolungarne la durata, deve essere duplicata utilizzando i rispettivi metodi dup() . L'istanza restituita può essere utilizzata oltre l'invocazione del metodo e dovrebbe essere chiusa correttamente una volta terminata.

Nel codice client generato, gli handle e le istanze di memoria inviate come argomenti di input del metodo chiamato non devono essere duplicati né mantenuti validi dopo la restituzione del metodo. Tuttavia, gli handle e le istanze di memoria ricevute come argomenti di output vengono automaticamente duplicati dal codice generato automaticamente e al termine devono essere chiusi correttamente. Ciò è vero se tali argomenti restituiti vengono visualizzati come valori restituiti del metodo (nel caso del valore restituito singolo) o utilizzando lo stile di callback sincrono (utilizzato nel caso del valore restituito multiplo).

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

Array e vettori

Gli array vengono tradotti in array Java e i vettori vengono tradotti in ArrayList<T> dove T è il tipo di oggetto appropriato, possibilmente racchiudendo tipi scalari come vec<int32_t> => ArrayList<Integer> ). Per 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 livello superiore dichiarato types.hal ottiene il proprio file di output .java (come richiesto da Java). Ad esempio, il seguente 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).