Types de données

Étant donné un fichier d'interface HIDL, le backend Java HIDL génère des interfaces Java, du code Stub et Proxy. Il prend en charge tous les types HIDL scalaires ([ u ] int { 8,16,32,64}_t, float, double, et enum s), ainsi que les chaînes, les interfaces, les types safe_union, les types struct et les tableaux et vecteurs de supports pris en charge. Types HIDL. Le backend Java HIDL ne prend PAS en charge les types union ou les types fmq . Android 11 ajoute la prise en charge des types memory et handle .

Comme le runtime Java ne prend pas en charge nativement le concept d'entiers non signés, tous les types non signés (et les énumérations basées sur eux) sont traités silencieusement comme leurs équivalents signés, c'est-à-dire que uint32_t devient un int dans l'interface Java. Aucune conversion de valeur n'est effectuée ; l'implémenteur côté Java doit utiliser les valeurs signées comme si elles n'étaient pas signées.

Énumérations

Les énumérations ne génèrent pas de classes d'énumération Java mais sont plutôt traduites en classes internes contenant une définition de constante statique pour chaque cas d'énumération. Si la classe enum dérive d’une autre classe enum, elle hérite du type de stockage de cette classe. Les énumérations basées sur un type entier non signé sont réécrites dans leur équivalent signé. Étant donné que le type sous-jacent est une primitive, la valeur par défaut des champs/variables d'énumération est zéro même lorsqu'il n'y a pas d'énumérateur nul.

Par exemple, un SomeBaseEnum avec un type uint8_t :

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

… devient:

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

Et:

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

… est réécrit comme suit :

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

Cordes

Les String en Java sont utf-8 ou utf-16 mais sont converties en utf-8 comme type HIDL commun lors du transport. De plus, une String ne doit pas être nulle lorsqu'elle est transmise à HIDL.

Poignée et mémoire

Android 11 introduit la prise en charge Java pour les types handle et memory . Ils sont traduits respectivement en android.os.NativeHandle et android.os.HidlMemory . Un handle nul est considéré comme valide, alors qu’une mémoire nulle ne l’est pas.

Dans le code serveur généré, les arguments de mémoire et de handle reçus ne sont valides que dans le cadre de l’invocation de la méthode. Si l'implémentation du serveur souhaite prolonger leur durée de vie, ils doivent être dupliqués à l'aide de leurs méthodes dup() respectives. L'instance renvoyée peut être utilisée au-delà de l'invocation de la méthode et doit être correctement fermée une fois l'opération terminée.

Dans le code client généré, les handles et les instances de mémoire envoyées comme arguments d'entrée de la méthode appelée n'ont pas besoin d'être dupliqués ni conservés valides après le retour de la méthode. Cependant, les handles et les instances de mémoire reçus comme arguments de sortie sont automatiquement dupliqués par le code généré automatiquement et doivent être correctement fermés une fois terminés. Cela est vrai que ces arguments de retour apparaissent comme valeurs de retour de la méthode (dans le cas d'une valeur de retour unique) ou en utilisant le style de rappel synchrone (utilisé dans le cas de valeurs de retour multiples).

Pour plus d'informations sur la duplication et la fermeture, consultez la documentation des classes Java.

Tableaux et vecteurs

Les tableaux sont traduits en tableaux Java et les vecteurs sont traduits en ArrayList<T> où T est le type d'objet approprié, enveloppant éventuellement des types scalaires tels que vec<int32_t> => ArrayList<Integer> ). Par exemple:

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

… devient:

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

Structures

Les structures sont traduites en classes Java avec une présentation similaire. Par exemple:

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

… devient:

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

Types déclarés

Chaque type de niveau supérieur déclaré dans types.hal obtient son propre fichier de sortie .java (comme requis par Java). Par exemple, le fichier types.hal suivant entraîne la création de deux fichiers supplémentaires (Foo.java et Bar.java) :

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

La définition de Baz réside dans une classe interne statique de Bar (dans Bar.java).