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

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

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

เอนัม

Enums ไม่ได้สร้างคลาส Java 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() ซ้ำกัน อินสแตนซ์ที่ส่งคืนสามารถใช้งานได้นอกเหนือจากการเรียกใช้เมธอด และควรปิดอย่างถูกต้องเมื่อดำเนินการเสร็จสิ้น

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการทำซ้ำและการปิด โปรดดูเอกสารประกอบของคลาส 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)