เมื่อมีไฟล์อินเทอร์เฟซ 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
)