डेटा टाइप

एचआईडीएल इंटरफ़ेस फ़ाइल दिए जाने पर, Java एचआईडीएल बैकएंड, Java इंटरफ़ेस, स्टब, और प्रॉक्सी कोड जनरेट करता है. यह सभी स्केलर HIDL टाइप ([u]int{8,16,32,64}_t, float, double, और enums) के साथ-साथ स्ट्रिंग, इंटरफ़ेस, safe_union टाइप, struct टाइप, और HIDL टाइप के ऐरे और वेक्टर के साथ काम करता है. Java HIDL बैकएंड, यूनियन टाइप या fmq टाइप के साथ काम नहीं करता. Android 11 में, memory और handle टाइप के लिए सहायता जोड़ी गई है.

Java रनटाइम, बिना साइन किए गए पूर्णांकों के कॉन्सेप्ट को नेटिव तौर पर सपोर्ट नहीं करता है.इसलिए, बिना साइन किए गए सभी टाइप (और उन पर आधारित enum) को चुपचाप उनके साइन किए गए इक्विवेलेंट के तौर पर माना जाता है. इसका मतलब है कि Java इंटरफ़ेस में uint32_t, int बन जाता है. कोई वैल्यू कन्वर्ज़न नहीं किया जाता है. Java साइड पर लागू करने वाले व्यक्ति को, साइन की गई वैल्यू का इस्तेमाल इस तरह करना चाहिए जैसे वे साइन नहीं की गई हैं.

Enums

एनम, Java एनम क्लास जनरेट नहीं करते हैं. इसके बजाय, इन्हें इनर क्लास में बदला जाता है. इनमें हर एनम केस के लिए स्टैटिक कॉन्स्टेंट की परिभाषा होती है. अगर enum क्लास किसी दूसरी enum क्लास से मिलती-जुलती है, तो उसे उस क्लास का स्टोरेज टाइप मिलता है. बिना साइन किए गए पूर्णांक टाइप के आधार पर बनाए गए इन्यूमरेशन को, साइन किए गए उनके बराबर के टाइप में फिर से लिखा जाता है. बाइनरी फ़ाइल का टाइप प्रिमिटिव होने की वजह से, enum फ़ील्ड/वैरिएबल की डिफ़ॉल्ट वैल्यू शून्य होती है. भले ही, कोई शून्य एन्यूमरेटर न हो.

उदाहरण के लिए, uint8_t टाइप वाला SomeBaseEnum:

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

… हो जाता है:

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

और:

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

… को इस तरह से फिर से लिखा गया है:

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

स्ट्रिंग

Java में String, utf-8 या utf-16 होता है. हालांकि, ट्रांसपोर्ट किए जाने पर इसे सामान्य HIDL टाइप के तौर पर utf-8 में बदल दिया जाता है. इसके अलावा, HIDL में पास किए जाने पर String शून्य नहीं होना चाहिए.

हैंडल और मेमोरी

Android 11 में, handle और memory टाइप के लिए Java का इस्तेमाल किया जा सकता है. इनका अनुवाद, android.os.NativeHandle और android.os.HidlMemory में किया गया है. शून्य हैंडल को मान्य माना जाता है, जबकि शून्य मेमोरी को मान्य नहीं माना जाता.

जनरेट किए गए सर्वर कोड में, मेमोरी और हैंडल आर्ग्युमेंट सिर्फ़ तरीके के इनवॉकेशन के दायरे में मान्य होते हैं. अगर सर्वर को लंबे समय तक इस्तेमाल करना है, तो उन्हें dup() के अलग-अलग तरीकों का इस्तेमाल करके डुप्लीकेट करना होगा. लौटाए गए इंस्टेंस का इस्तेमाल, तरीके को लागू करने के बाद भी किया जा सकता है. हालांकि, इस्तेमाल पूरा होने के बाद इसे बंद कर देना चाहिए.

जनरेट किए गए क्लाइंट कोड में, कॉल किए गए तरीके के इनपुट आर्ग्युमेंट के तौर पर भेजे गए हैंडल और मेमोरी इंस्टेंस को डुप्लीकेट करने की ज़रूरत नहीं होती. साथ ही, तरीके के वापस आने के बाद उन्हें मान्य रखने की भी ज़रूरत नहीं होती. हालांकि, आउटपुट आर्ग्युमेंट के तौर पर मिले हैंडल और मेमोरी इंस्टेंस, अपने-आप जनरेट होने वाले कोड से अपने-आप डुप्लीकेट हो जाते हैं. इसलिए, काम पूरा होने के बाद इन्हें ठीक से बंद करना ज़रूरी है. ऐसा तब भी होता है, जब ये रिटर्न आर्ग्युमेंट, तरीके की रिटर्न वैल्यू के तौर पर दिखते हैं (एक रिटर्न वैल्यू के मामले में) या सिंक्रोनस कॉलबैक स्टाइल का इस्तेमाल करके दिखते हैं (एक से ज़्यादा रिटर्न वैल्यू के मामले में).

डुप्लीकेट होने और बंद होने के बारे में ज़्यादा जानकारी के लिए, Java क्लास का दस्तावेज़ देखें.

ऐरे और वेक्टर

ऐरे को Java ऐरे में बदला जाता है और वेक्टर को ArrayList<T> में बदला जाता है. यहां T, सही ऑब्जेक्ट टाइप है. यह vec<int32_t> => ArrayList<Integer> जैसे स्केलर टाइप को रैप कर सकता है. उदाहरण के लिए:

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

… हो जाता है:

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

स्ट्रक्चर

स्ट्रक्चर को Java क्लास में बदला जाता है. इनका लेआउट एक जैसा होता है. उदाहरण के लिए:

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

… हो जाता है:

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.hal में एलान किए गए हर टॉप-लेवल टाइप के लिए, एक अलग .java आउटपुट फ़ाइल मिलती है. यह Java की ज़रूरी शर्त है. उदाहरण के लिए, यहां दी गई types.hal फ़ाइल से दो अतिरिक्त फ़ाइलें (Foo.java और Bar.java) बनती हैं:

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

Baz की परिभाषा, Bar की स्टैटिक इनर क्लास (Bar.java में) में मौजूद होती है.