ประเภทข้อมูล

เมื่อมีไฟล์อินเทอร์เฟซ HIDL แบ็กเอนด์ Java HIDL จะสร้างอินเทอร์เฟซ Java รหัส Stub และรหัสพร็อกซี รองรับสเกลาร์ HIDL ทุกประเภท ([u]int{8,16,32,64}_t, float, double, และ enum) รวมทั้งสตริง อินเทอร์เฟซ ประเภท Safe_union และ struct และอาร์เรย์และเวกเตอร์ของประเภท HIDL ที่รองรับ แบ็กเอนด์ Java HIDL ไม่รองรับประเภทการรวมหรือประเภท Fmq Android 11 เพิ่มการสนับสนุนสำหรับ memory และ handle ประเภท

เนื่องจากรันไทม์ของ Java ไม่รองรับแนวคิดของจำนวนเต็มที่ไม่มีเครื่องหมาย ประเภทที่ไม่ได้ลงนามทั้งหมด (และ enum ที่อิงตามประเภทเหล่านั้น) จะได้รับการปฏิบัติอย่างเงียบๆ ว่าเป็น จำนวนที่เทียบเท่าแบบมีเครื่องหมาย เช่น uint32_t จะกลายเป็น int ใน อินเทอร์เฟซ Java ไม่มี Conversion มูลค่า ใน ฝั่ง Java ต้องใช้ค่าที่ลงชื่อราวกับว่าเป็นค่าที่ไม่ได้ลงชื่อ

Enums

Enum จะไม่สร้างคลาส Java enum แต่จะแปลเป็นคลาสภายในแทน คลาสที่มีคำจำกัดความคงที่คงที่สำหรับกรณี enum แต่ละกรณี หาก Enum คลาสที่มาจากคลาส enum อื่นๆ บางส่วนจะรับค่าของประเภทพื้นที่เก็บข้อมูลของคลาสนั้น การแจงนับตามประเภทจำนวนเต็มที่ไม่มีเครื่องหมายจะเขียนใหม่ลงในเครื่องหมาย เทียบเท่า เนื่องจากประเภทที่สำคัญเป็นค่าพื้นฐาน ค่าเริ่มต้นสำหรับ ฟิลด์/ตัวแปร enum จะเป็นศูนย์แม้ว่าจะไม่มีตัวระบุเป็นศูนย์ก็ตาม

ตัวอย่างเช่น SomeBaseEnum ที่มีประเภทเป็น uint8_t:

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

เครื่องสาย

String ใน Java คือ utf-8 หรือ utf-16 แต่แปลงเป็น utf-8 เป็นประเภท HIDL ทั่วไปเมื่อขนส่ง นอกจากนี้ String ต้องไม่เป็นค่าว่างเมื่อส่งผ่านไปยัง HIDL

แฮนเดิลและหน่วยความจำ

Android 11 เปิดตัวการรองรับ Java สำหรับ handle และ memory ประเภท โดยจะได้รับการแปลเป็นภาษาandroid.os.NativeHandleและ android.os.HidlMemory ตามลำดับ แฮนเดิล Null จะถือว่าถูกต้อง แต่เป็น Null ความทรงจำนั้นใช้ไม่ได้

ในโค้ดของเซิร์ฟเวอร์ที่สร้างขึ้น อาร์กิวเมนต์หน่วยความจำและแฮนเดิลที่ได้รับมีเพียง ใช้งานได้ภายในขอบเขตของการเรียกใช้เมธอด หากการใช้งานเซิร์ฟเวอร์ต้องการขยายเวลา ตลอดอายุการใช้งาน ต้องทำซ้ำโดยใช้เมธอด dup() ที่เกี่ยวข้อง สามารถใช้อินสแตนซ์ที่แสดงผลนอกเหนือจากการเรียกใช้ได้ และควรปิดอย่างเหมาะสมเมื่อทำเสร็จแล้ว ด้วย

ในโค้ดไคลเอ็นต์ที่สร้างขึ้น แฮนเดิลและอินสแตนซ์หน่วยความจำ ส่งเป็นอาร์กิวเมนต์อินพุตของวิธีการที่เรียกใช้ไม่จำเป็นต้องทำซ้ำหรือเก็บไว้ ใช้ได้หลังจากเมธอดแสดงผล แต่แฮนเดิลและอินสแตนซ์หน่วยความจำที่ received เนื่องจากอาร์กิวเมนต์เอาต์พุตจะทำซ้ำโดยอัตโนมัติโดยฟิลด์ โค้ดที่สร้างขึ้นโดยอัตโนมัติและต้องปิดอย่างถูกต้องเมื่อทำเสร็จแล้ว กรณีนี้เกิดขึ้นไม่ว่าผลตอบแทนเหล่านั้น อาร์กิวเมนต์จะปรากฏเป็นค่าที่ส่งกลับของเมธอด (ในกรณีของฟังก์ชันค่าผลลัพธ์เดียว) หรือใช้ฟังก์ชัน รูปแบบ Callback แบบซิงโครนัส (ใช้ในกรณีส่งกลับค่าหลายรายการ)

ดูข้อมูลเพิ่มเติมเกี่ยวกับการทำซ้ำและการปิดได้ในเอกสารประกอบของคลาส 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 ต้องการ) ตัวอย่างเช่น URL ต่อไปนี้ types.hal ไฟล์ทำให้มีการสร้างไฟล์เพิ่มเติม 2 ไฟล์ (Foo.java และ Bar.java):

struct Foo {
 ...
};

struct Bar {
 ...

 struct Baz {
 };

 ...
};

คำจำกัดความของ Baz อยู่ในเกณฑ์ชั้นในแบบคงที่ของบาร์ (ใน Bar.java)