ภาษานิยามอินเทอร์เฟซ Android (AIDL)

ภาษาที่ใช้สื่อสารข้อมูลระหว่างคอมโพเนนต์ของ Android (AIDL) คล้ายกับ IDL อื่นๆ ตรงที่ช่วยให้คุณกำหนดอินเทอร์เฟซการเขียนโปรแกรมที่ทั้งไคลเอ็นต์และบริการตกลงกันเพื่อสื่อสารกันโดยใช้การสื่อสารระหว่างโปรเซส (IPC)

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

หมายเหตุ: AIDL จำเป็นเฉพาะในกรณีที่คุณอนุญาตให้ไคลเอ็นต์จากแอปพลิเคชันต่างๆ เข้าถึงบริการของคุณสำหรับ IPC และคุณต้องการจัดการมัลติเธรดในบริการของคุณ หากไม่จำเป็นต้องใช้ IPC พร้อมกันในแอปพลิเคชันต่างๆ ให้สร้างอินเทอร์เฟซโดยใช้ Binder หากต้องการใช้ IPC แต่ไม่จำเป็นต้องจัดการมัลติเธรด ให้ใช้อินเทอร์เฟซโดยใช้ Messenger อย่างไรก็ตาม โปรดทำความเข้าใจบริการที่มีผลผูกพันก่อนที่จะใช้ AIDL

ก่อนเริ่มออกแบบอินเทอร์เฟซ AIDL โปรดทราบว่าการเรียกใช้อินเทอร์เฟซ AIDL เป็นการเรียกใช้ฟังก์ชันโดยตรง อย่าตั้งสมมติฐานเกี่ยวกับชุดข้อความที่เกิดการเรียกใช้ สิ่งที่เกิดขึ้นจะแตกต่างกันไปโดยขึ้นอยู่กับว่าการเรียกมาจากชุดข้อความในกระบวนการภายในหรือกระบวนการระยะไกล ดังนี้

  • การเรียกที่ทำจากกระบวนการในเครื่องจะดำเนินการในชุดข้อความเดียวกันกับที่ทำการเรียก หากนี่คือเธรด UI หลัก เธรดนั้นจะยังคงทำงานต่อไปในอินเทอร์เฟซ AIDL หากเป็นชุดข้อความอื่น ชุดข้อความนั้นจะเป็นชุดข้อความที่เรียกใช้โค้ดของคุณในบริการ ดังนั้น หากมีเพียงเทรดในเครื่องที่เข้าถึงบริการ คุณจะควบคุมได้อย่างสมบูรณ์ว่าเทรดใดจะทำงานในบริการนั้น แต่หากเป็นเช่นนั้น อย่าใช้ AIDL เลย ให้สร้างอินเทอร์เฟซโดยใช้ Binder แทน
  • การเรียกจากกระบวนการระยะไกลจะส่งมาจาก Thread Pool ที่แพลตฟอร์มดูแลรักษาภายในกระบวนการของคุณเอง เตรียมพร้อมรับสายเรียกเข้าจากชุดข้อความที่ไม่รู้จัก โดยอาจมีสายเรียกเข้าหลายสายพร้อมกัน กล่าวคือ การใช้งานอินเทอร์เฟซ AIDL ต้องปลอดภัยจากเทรดโดยสมบูรณ์ การเรียกที่ทำจากชุดข้อความหนึ่งในออบเจ็กต์ระยะไกลเดียวกันจะมาถึงตามลำดับที่ฝั่งผู้รับ
  • คีย์เวิร์ด oneway จะแก้ไขลักษณะการทำงานของการเรียกใช้ระยะไกล เมื่อใช้ฟีเจอร์นี้ ระบบจะไม่บล็อกการโทรระยะไกล โดยจะส่งข้อมูลธุรกรรมและแสดงผลทันที ในที่สุดการติดตั้งใช้งานอินเทอร์เฟซจะได้รับข้อมูลนี้เป็นการเรียกใช้ปกติจาก Thread Pool ของ Binder เป็นการเรียกใช้ระยะไกลตามปกติ หากใช้ oneway กับการเรียกใช้ในเครื่อง จะไม่มีผลกระทบใดๆ และการเรียกใช้จะยังคงเป็นแบบซิงโครนัส

การกำหนดอินเทอร์เฟซ AIDL

กำหนดอินเทอร์เฟซ AIDL ในไฟล์ .aidl โดยใช้ไวยากรณ์ภาษาโปรแกรม Java จากนั้นบันทึกไว้ในซอร์สโค้ดในไดเรกทอรี src/ ของทั้งแอปพลิเคชันที่โฮสต์บริการและแอปพลิเคชันอื่นๆ ที่เชื่อมโยงกับบริการ

เมื่อคุณสร้างแอปพลิเคชันแต่ละรายการที่มีไฟล์ .aidl เครื่องมือ Android SDK จะสร้างอินเทอร์เฟซ IBinder โดยอิงตามไฟล์ .aidl และบันทึกไว้ในไดเรกทอรี gen/ ของโปรเจ็กต์ บริการต้องใช้อินเทอร์เฟซ IBinder ตามความเหมาะสม จากนั้นแอปพลิเคชันไคลเอ็นต์จะเชื่อมโยงกับบริการและเรียกใช้เมธอดจาก IBinder เพื่อดำเนินการ IPC ได้

หากต้องการสร้างบริการที่มีผลผูกพันโดยใช้ AIDL ให้ทำตามขั้นตอนต่อไปนี้ ซึ่งอธิบายไว้ในส่วนถัดไป

  1. สร้างไฟล์ .aidl

    ไฟล์นี้จะกำหนดอินเทอร์เฟซการเขียนโปรแกรมด้วยซิกเนเจอร์ของเมธอด

  2. ใช้อินเทอร์เฟซ

    เครื่องมือ Android SDK จะสร้างอินเทอร์เฟซในภาษาโปรแกรม Java โดยอิงตามไฟล์ .aidl ของคุณ อินเทอร์เฟซนี้มีคลาสนามธรรมภายในชื่อ Stub ซึ่งขยาย Binder และใช้เมธอดจากอินเทอร์เฟซ AIDL คุณต้องขยายคลาส Stub และใช้เมธอด

  3. แสดงอินเทอร์เฟซต่อไคลเอ็นต์

    ใช้ Service และลบล้าง onBind() เพื่อแสดงผลการใช้งานคลาส Stub

ข้อควรระวัง: การเปลี่ยนแปลงใดๆ ที่คุณทำกับอินเทอร์เฟซ AIDL หลังจากเผยแพร่ครั้งแรกจะต้องเข้ากันได้แบบย้อนหลังเพื่อหลีกเลี่ยงไม่ให้แอปพลิเคชันอื่นๆ ที่ใช้บริการของคุณหยุดทำงาน กล่าวคือ เนื่องจากต้องคัดลอกไฟล์ .aidl ไปยังแอปพลิเคชันอื่นๆ เพื่อให้แอปพลิเคชันเหล่านั้นเข้าถึงอินเทอร์เฟซของบริการได้ คุณจึงต้องคงการรองรับอินเทอร์เฟซเดิมไว้

สร้างไฟล์ .aidl

AIDL ใช้ไวยากรณ์ง่ายๆ ที่ช่วยให้คุณประกาศอินเทอร์เฟซที่มีเมธอดอย่างน้อย 1 เมธอดซึ่งสามารถรับพารามิเตอร์และแสดงผลค่าได้ พารามิเตอร์และค่าที่แสดงผลอาจเป็นประเภทใดก็ได้ แม้แต่อินเทอร์เฟซอื่นๆ ที่ AIDL สร้างขึ้น

คุณต้องสร้างไฟล์ .aidl โดยใช้ภาษาโปรแกรม Java ไฟล์ .aidl แต่ละไฟล์ต้องกำหนดอินเทอร์เฟซเดียว และต้องมีการประกาศอินเทอร์เฟซและซิกเนเจอร์ของเมธอดเท่านั้น

โดยค่าเริ่มต้น AIDL จะรองรับประเภทข้อมูลต่อไปนี้

  • ประเภทพื้นฐานทั้งหมด ยกเว้น short ในภาษาโปรแกรม Java (เช่น int, long, char, boolean และอื่นๆ)
  • อาร์เรย์ประเภทใดก็ได้ เช่น int[] หรือ MyParcelable[]
  • String
  • CharSequence
  • List

    องค์ประกอบทั้งหมดใน List ต้องเป็นประเภทข้อมูลที่รองรับประเภทใดประเภทหนึ่งในรายการนี้ หรือเป็นอินเทอร์เฟซหรือ Parcelable อื่นๆ ที่ AIDL สร้างขึ้นซึ่งคุณประกาศไว้ คุณสามารถเลือกใช้ List เป็นคลาสประเภทที่มีพารามิเตอร์ได้ เช่น List<String> คลาสที่เป็นรูปธรรมจริงที่อีกฝั่งได้รับจะเป็น ArrayList เสมอ แม้ว่าเมธอดจะสร้างขึ้นเพื่อใช้อินเทอร์เฟซ List ก็ตาม

  • Map

    องค์ประกอบทั้งหมดใน Map ต้องเป็นประเภทข้อมูลที่รองรับประเภทใดประเภทหนึ่งในรายการนี้ หรือเป็นอินเทอร์เฟซหรือ Parcelable อื่นๆ ที่ AIDL สร้างขึ้นซึ่งคุณประกาศไว้ ระบบไม่รองรับการแมปประเภทที่มีพารามิเตอร์ เช่น การแมปในรูปแบบ Map<String,Integer> คลาสที่เป็นรูปธรรมจริงที่อีกฝั่งได้รับจะเป็น HashMap เสมอ แม้ว่าเมธอดจะสร้างขึ้นเพื่อใช้อินเทอร์เฟซ Map ก็ตาม ลองใช้ Bundle แทน Map

คุณต้องใส่คำสั่ง import สำหรับประเภทเพิ่มเติมแต่ละประเภทที่ไม่ได้ระบุไว้ก่อนหน้านี้ แม้ว่าจะกำหนดไว้ในแพ็กเกจเดียวกับอินเทอร์เฟซก็ตาม

เมื่อกำหนดอินเทอร์เฟซบริการ โปรดทราบว่า

  • เมธอดสามารถรับพารามิเตอร์ได้ตั้งแต่ 0 ตัวขึ้นไป และสามารถแสดงผลค่าหรือค่าว่างได้
  • พารามิเตอร์ที่ไม่ใช่แบบพื้นฐานทั้งหมดต้องมีแท็กทิศทางที่ระบุว่าข้อมูลจะไปทางใด ได้แก่ in, out หรือ inout (ดูตัวอย่างด้านล่าง)

    โดยค่าเริ่มต้น ข้อมูลพื้นฐาน, String, IBinder และอินเทอร์เฟซที่ AIDL สร้างขึ้นจะเป็น in และไม่สามารถเป็นอย่างอื่นได้

    ข้อควรระวัง: จำกัดทิศทางให้เหลือเฉพาะสิ่งที่จำเป็นจริงๆ เนื่องจากพารามิเตอร์การจัดระเบียบมีค่าใช้จ่ายสูง

  • ความคิดเห็นเกี่ยวกับโค้ดทั้งหมดที่รวมอยู่ในไฟล์ .aidl จะรวมอยู่ในอินเทอร์เฟซ IBinder ที่สร้างขึ้น ยกเว้นความคิดเห็นก่อนคำสั่งนำเข้าและแพ็กเกจ
  • คุณสามารถกำหนดค่าคงที่สตริงและ int ในอินเทอร์เฟซ AIDL ได้ เช่น const int VERSION = 1;
  • การเรียกใช้เมธอดจะส่งโดยโค้ด transact() ซึ่งโดยปกติจะอิงตามดัชนีเมธอดในอินเทอร์เฟซ เนื่องจากวิธีนี้ทำให้การกำหนดเวอร์ชันทำได้ยาก คุณจึงสามารถกำหนดรหัสธุรกรรมให้กับเมธอดด้วยตนเองได้: void method() = 10;
  • อาร์กิวเมนต์และประเภทการแสดงผลที่เว้นว่างได้ต้องมีคำอธิบายประกอบโดยใช้ @nullable

ตัวอย่างไฟล์ .aidl มีดังนี้

// IRemoteService.aidl
package com.example.android;

// Declare any non-default types here with import statements.

/** Example service interface. */
interface IRemoteService {
    /** Request the process ID of this service. */
    int getPid();

    /** Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

บันทึกไฟล์ .aidl ในไดเรกทอรี src/ ของโปรเจ็กต์ เมื่อคุณสร้างแอปพลิเคชัน SDK Tools จะสร้างไฟล์อินเทอร์เฟซ IBinder ในไดเรกทอรี gen/ ของโปรเจ็กต์ ชื่อไฟล์ที่สร้างขึ้นจะตรงกับชื่อไฟล์ .aidl แต่มีนามสกุล .java เช่น IRemoteService.aidl จะได้ผลลัพธ์เป็น IRemoteService.java

หากคุณใช้ Android Studio บิลด์ที่เพิ่มขึ้นจะสร้างคลาส Binder เกือบจะทันที หากคุณไม่ได้ใช้ Android Studio เครื่องมือ Gradle จะสร้างคลาส Binder ในครั้งถัดไปที่คุณสร้างแอปพลิเคชัน สร้างโปรเจ็กต์ด้วย gradle assembleDebug หรือ gradle assembleRelease ทันทีที่เขียนไฟล์ .aidl เสร็จ เพื่อให้โค้ดลิงก์กับคลาสที่สร้างขึ้นได้

ใช้อินเทอร์เฟซ

เมื่อคุณสร้างแอปพลิเคชัน เครื่องมือ Android SDK จะสร้างไฟล์อินเทอร์เฟซ .java ที่ตั้งชื่อตามไฟล์ .aidl ของคุณ อินเทอร์เฟซที่สร้างขึ้นจะมีคลาสย่อยชื่อ Stub ซึ่งเป็นการใช้งานแบบนามธรรมของอินเทอร์เฟซหลัก เช่น YourInterface.Stub และประกาศเมธอดทั้งหมดจากไฟล์ .aidl

หมายเหตุ: Stub ยังกำหนดเมธอดตัวช่วยบางอย่างด้วย โดยเฉพาะ asInterface() ซึ่งใช้ IBinder (โดยปกติจะเป็นเมธอดที่ส่งไปยังเมธอด Callback onServiceConnected() ของไคลเอ็นต์) และแสดงผลอินสแตนซ์ของอินเทอร์เฟซ Stub ดูรายละเอียดเพิ่มเติมเกี่ยวกับวิธีแคสต์นี้ได้ที่ส่วนการเรียกใช้เมธอด IPC

หากต้องการใช้อินเทอร์เฟซที่สร้างจาก .aidl ให้ขยายอินเทอร์เฟซ Binder ที่สร้างขึ้น เช่น YourInterface.Stub และใช้เมธอดที่รับค่ามาจากไฟล์ .aidl

ต่อไปนี้คือตัวอย่างการใช้งานอินเทอร์เฟซที่ชื่อ IRemoteService ซึ่งกำหนดโดยตัวอย่าง IRemoteService.aidl ก่อนหน้า โดยใช้อินสแตนซ์ที่ไม่ระบุตัวตน

private val binder = object : IRemoteService.Stub() {

    override fun getPid(): Int =
        Process.myPid()

    override fun basicTypes(
        anInt: Int,
        aLong: Long,
        aBoolean: Boolean,
        aFloat: Float,
        aDouble: Double,
        aString: String
    ) {
        // Does nothing.
    }
}

ตอนนี้ binder เป็นอินสแตนซ์ของคลาส Stub (Binder) ซึ่งกำหนดอินเทอร์เฟซ IPC สำหรับบริการ ในขั้นตอนถัดไป อินสแตนซ์นี้จะแสดงต่อไคลเอ็นต์เพื่อให้ไคลเอ็นต์โต้ตอบกับบริการได้

โปรดคำนึงถึงกฎบางข้อเมื่อใช้อินเทอร์เฟซ AIDL ดังนี้

  • ระบบไม่รับประกันว่าการเรียกเข้าจะดำเนินการในเทรดหลัก ดังนั้นคุณจึงต้องคำนึงถึงมัลติเทรดตั้งแต่เริ่มต้นและสร้างบริการให้ปลอดภัยต่อเทรดอย่างเหมาะสม
  • โดยค่าเริ่มต้น การเรียก IPC จะเป็นแบบซิงโครนัส หากคุณทราบว่าบริการใช้เวลามากกว่า 2-3 มิลลิวินาทีในการดำเนินการตามคำขอให้เสร็จสมบูรณ์ อย่าเรียกใช้บริการจากเทรดหลักของกิจกรรม ซึ่งอาจทำให้แอปพลิเคชันค้าง ส่งผลให้ Android แสดงกล่องโต้ตอบ "แอปพลิเคชันไม่ตอบสนอง" เรียกใช้จากชุดข้อความแยกต่างหากในไคลเอ็นต์
  • ระบบจะส่งเฉพาะประเภทข้อยกเว้นที่แสดงในเอกสารอ้างอิงสำหรับ Parcel.writeException() กลับไปยังผู้โทร

แสดงอินเทอร์เฟซให้ลูกค้าเห็น

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

class RemoteService : Service() {

    override fun onCreate() {
        super.onCreate()
    }

    override fun onBind(intent: Intent): IBinder {
        // Return the interface.
        return binder
    }

    private val binder = object : IRemoteService.Stub() {
        override fun getPid(): Int {
            return Process.myPid()
        }

        override fun basicTypes(
            anInt: Int,
            aLong: Long,
            aBoolean: Boolean,
            aFloat: Float,
            aDouble: Double,
            aString: String
        ) {
            // Does nothing.
        }
    }
}

ตอนนี้ เมื่อไคลเอ็นต์ เช่น กิจกรรม เรียกใช้ bindService() เพื่อเชื่อมต่อกับบริการนี้ Callback onServiceConnected() ของไคลเอ็นต์จะได้รับอินสแตนซ์ binder ที่แสดงผลโดยเมธอด onBind() ของบริการ

ไคลเอ็นต์ต้องมีสิทธิ์เข้าถึงคลาสอินเทอร์เฟซด้วย ดังนั้นหากไคลเอ็นต์และบริการอยู่ในแอปพลิเคชันแยกกัน แอปพลิเคชันของไคลเอ็นต์ต้องมีสำเนาไฟล์ .aidl ในไดเรกทอรี src/ ซึ่งจะสร้างอินเทอร์เฟซ android.os.Binder เพื่อให้ไคลเอ็นต์เข้าถึงเมธอด AIDL ได้

เมื่อไคลเอ็นต์ได้รับ IBinder ใน Callback onServiceConnected() ไคลเอ็นต์ต้องเรียกใช้ YourServiceInterface.Stub.asInterface(service) เพื่อแคสต์พารามิเตอร์ที่แสดงผลเป็นประเภท YourServiceInterface ดังนี้

var iRemoteService: IRemoteService? = null

val mConnection = object : ServiceConnection {

    // Called when the connection with the service is established.
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        // Following the preceding example for an AIDL interface,
        // this gets an instance of the IRemoteInterface, which we can use to call on the service.
        iRemoteService = IRemoteService.Stub.asInterface(service)
    }

    // Called when the connection with the service disconnects unexpectedly.
    override fun onServiceDisconnected(className: ComponentName) {
        Log.e(TAG, "Service has unexpectedly disconnected")
        iRemoteService = null
    }
}

ดูโค้ดตัวอย่างเพิ่มเติมได้ที่คลาส RemoteService.java ใน ApiDemos

การส่งออบเจ็กต์ผ่าน IPC

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

package android.graphics;

// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect {
    int left;
    int top;
    int right;
    int bottom;
}

ตัวอย่างโค้ดก่อนหน้าจะสร้างคลาส Java โดยอัตโนมัติด้วยช่องจำนวนเต็ม left, top, right และ bottom โค้ดการจัดระเบียบที่เกี่ยวข้องทั้งหมดจะถูกนำไปใช้โดยอัตโนมัติ และสามารถใช้ออบเจ็กต์ได้โดยตรงโดยไม่ต้องเพิ่มการใช้งานใดๆ

นอกจากนี้ คุณยังส่งคลาสที่กำหนดเองจากกระบวนการหนึ่งไปยังอีกกระบวนการหนึ่งผ่านอินเทอร์เฟซ IPC ได้ด้วย อย่างไรก็ตาม โปรดตรวจสอบว่าโค้ดสำหรับคลาสของคุณพร้อมใช้งานในอีกด้านหนึ่งของช่องทาง IPC และคลาสของคุณต้องรองรับอินเทอร์เฟซ Parcelable การรองรับ Parcelable เป็นสิ่งสำคัญเนื่องจากช่วยให้ระบบ Android แยกย่อยออบเจ็กต์เป็นองค์ประกอบพื้นฐานที่สามารถจัดระเบียบข้ามกระบวนการได้

หากต้องการสร้างคลาสที่กำหนดเองซึ่งรองรับ Parcelable ให้ทำดังนี้

  1. ทำให้คลาสของคุณใช้อินเทอร์เฟซ Parcelable
  2. ใช้ writeToParcel ซึ่งจะใช้สถานะปัจจุบันของออบเจ็กต์และเขียนลงใน Parcel
  3. เพิ่มช่องแบบคงที่ชื่อ CREATOR ลงในคลาสซึ่งเป็นออบเจ็กต์ที่ใช้ อินเทอร์เฟซ Parcelable.Creator
  4. สุดท้าย ให้สร้างไฟล์ .aidl ที่ประกาศคลาส Parcelable ดังที่แสดงในไฟล์ Rect.aidl ต่อไปนี้

    หากคุณใช้กระบวนการบิลด์ที่กำหนดเอง อย่าเพิ่มไฟล์ .aidl ลงในบิลด์ ไฟล์ .aidl นี้จะไม่ได้รับการคอมไพล์ ซึ่งคล้ายกับไฟล์ส่วนหัวในภาษา C

AIDL ใช้วิธีการและฟิลด์เหล่านี้ในโค้ดที่สร้างขึ้นเพื่อจัดระเบียบและยกเลิกการจัดระเบียบออบเจ็กต์

ตัวอย่างเช่น ต่อไปนี้คือไฟล์ Rect.aidl สำหรับสร้างคลาส Rect ที่เป็น Parcelable

package android.graphics;

// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect;

และนี่คือตัวอย่างวิธีที่คลาส Rect ใช้โปรโตคอล Parcelable

// import android.os.Parcel
// import android.os.Parcelable

class Rect() : Parcelable {
    var left: Int = 0
    var top: Int = 0
    var right: Int = 0
    var bottom: Int = 0

    companion object CREATOR : Parcelable.Creator<Rect> {
        override fun createFromParcel(parcel: Parcel): Rect {
            return Rect(parcel)
        }

        override fun newArray(size: Int): Array<Rect?> {
            return Array(size) { null }
        }
    }

    private constructor(inParcel: Parcel) : this() {
        readFromParcel(inParcel)
    }

    override fun writeToParcel(outParcel: Parcel, flags: Int) {
        outParcel.writeInt(left)
        outParcel.writeInt(top)
        outParcel.writeInt(right)
        outParcel.writeInt(bottom)
    }

    private fun readFromParcel(inParcel: Parcel) {
        left = inParcel.readInt()
        top = inParcel.readInt()
        right = inParcel.readInt()
        bottom = inParcel.readInt()
    }

    override fun describeContents(): Int {
        return 0
    }
}

การจัดระเบียบในคลาส Rect นั้นไม่ซับซ้อน ดูเมธอดอื่นๆ ใน Parcel เพื่อดูค่าประเภทอื่นๆ ที่คุณเขียนลงใน Parcel ได้

คำเตือน: โปรดคำนึงถึงผลกระทบด้านความปลอดภัยจากการรับข้อมูลจากกระบวนการอื่นๆ ในกรณีนี้ Rect จะอ่านตัวเลข 4 ตัวจาก Parcel แต่คุณต้องตรวจสอบว่าตัวเลขเหล่านี้อยู่ในช่วงค่าที่ยอมรับได้สำหรับสิ่งที่ผู้โทรพยายามทำ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีรักษาแอปพลิเคชันให้ปลอดภัยจากมัลแวร์ได้ที่เคล็ดลับด้านความปลอดภัย

เมธอดที่มีอาร์กิวเมนต์ Bundle ที่มี Parcelable

หากเมธอดรับออบเจ็กต์ Bundle ที่คาดว่าจะมี Parcelable ให้ตรวจสอบว่าคุณได้ตั้งค่า ClassLoader ของ Bundle โดยเรียกใช้ Bundle.setClassLoader(ClassLoader) ก่อนที่จะพยายามอ่านจาก Bundle มิฉะนั้น คุณจะพบ ClassNotFoundException แม้ว่าจะมีการกำหนด Parcelable อย่างถูกต้องในแอปพลิเคชันของคุณก็ตาม

ตัวอย่างเช่น ลองพิจารณาไฟล์ .aidl ตัวอย่างต่อไปนี้

// IRectInsideBundle.aidl
package com.example.android;

/** Example service interface. */
interface IRectInsideBundle {
    /** Rect parcelable is stored in the bundle with key "rect". */
    void saveRect(in Bundle bundle);
}
ดังที่แสดงในการใช้งานต่อไปนี้ ClassLoader จะได้รับการตั้งค่าอย่างชัดเจนใน Bundle ก่อนที่จะอ่าน Rect
private val binder = object : IRectInsideBundle.Stub() {
    override fun saveRect(bundle: Bundle) {
        bundle.classLoader = classLoader
        val rect = BundleCompat.getParcelable(bundle, "rect", Rect::class.java)
        process(rect) // Do more with the parcelable.
    }
}

กำลังเรียกใช้เมธอด IPC

หากต้องการเรียกใช้อินเทอร์เฟซระยะไกลที่กำหนดด้วย AIDL ให้ทำตามขั้นตอนต่อไปนี้ในคลาสการโทร

  1. ใส่ไฟล์ .aidl ในไดเรกทอรี src/ ของโปรเจ็กต์
  2. ประกาศอินสแตนซ์ของอินเทอร์เฟซ IBinder ซึ่งสร้างขึ้นตาม AIDL
  3. ใช้ ServiceConnection
  4. เรียกใช้ Context.bindService() โดยส่งผ่านการใช้งาน ServiceConnection
  5. ในการใช้งาน onServiceConnected() คุณจะได้รับอินสแตนซ์ IBinder ที่เรียกว่า service เรียกใช้ YourInterfaceName.Stub.asInterface((IBinder)service) เพื่อแคสต์พารามิเตอร์ที่แสดงผลไปยังประเภท YourInterface
  6. เรียกใช้เมธอดที่คุณกำหนดไว้ในอินเทอร์เฟซ ดักจับข้อยกเว้น DeadObjectException เสมอ ซึ่งจะแสดงขึ้นเมื่อการเชื่อมต่อขาดหาย นอกจากนี้ ให้ดักจับข้อยกเว้น SecurityException ซึ่งจะแสดงขึ้นเมื่อกระบวนการ 2 รายการที่เกี่ยวข้องในการเรียกใช้เมธอด IPC มีคำจำกัดความ AIDL ที่ขัดแย้งกัน
  7. หากต้องการยกเลิกการเชื่อมต่อ ให้เรียกใช้ Context.unbindService() ด้วยอินสแตนซ์ของอินเทอร์เฟซ

โปรดคำนึงถึงประเด็นต่อไปนี้เมื่อเรียกใช้บริการ IPC

  • ระบบจะนับการอ้างอิงออบเจ็กต์ในกระบวนการต่างๆ
  • คุณสามารถส่งออบเจ็กต์ที่ไม่ระบุตัวตนเป็นอาร์กิวเมนต์ของเมธอดได้

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเชื่อมโยงกับบริการได้ที่ภาพรวมของบริการที่มีผลผูกพัน

ต่อไปนี้คือโค้ดตัวอย่างที่แสดงการเรียกใช้บริการที่สร้างโดย AIDL ซึ่งนำมาจากตัวอย่างบริการระยะไกลในโปรเจ็กต์ ApiDemos

private const val BUMP_MSG = 1

class Binding : Activity() {

    /** The primary interface you call on the service.  */
    private var mService: IRemoteService? = null

    /** Another interface you use on the service.  */
    internal var secondaryService: ISecondary? = null

    private lateinit var killButton: Button
    private lateinit var callbackText: TextView
    private lateinit var handler: InternalHandler

    private var isBound: Boolean = false

    /**
     * Class for interacting with the main interface of the service.
     */
    private val mConnection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // This is called when the connection with the service is
            // established, giving us the service object we can use to
            // interact with the service.  We are communicating with our
            // service through an IDL interface, so get a client-side
            // representation of that from the raw service object.
            mService = IRemoteService.Stub.asInterface(service)
            killButton.isEnabled = true
            callbackText.text = "Attached."

            // We want to monitor the service for as long as we are
            // connected to it.
            try {
                mService?.registerCallback(mCallback)
            } catch (e: RemoteException) {
                // In this case, the service crashes before we can
                // do anything with it. We can count on soon being
                // disconnected (and then reconnected if it can be restarted)
                // so there is no need to do anything here.
            }

            // As part of the sample, tell the user what happened.
            Toast.makeText(
                    this@Binding,
                    R.string.remote_service_connected,
                    Toast.LENGTH_SHORT
            ).show()
        }

        override fun onServiceDisconnected(className: ComponentName) {
            // This is called when the connection with the service is
            // unexpectedly disconnected&mdash;that is, its process crashed.
            mService = null
            killButton.isEnabled = false
            callbackText.text = "Disconnected."

            // As part of the sample, tell the user what happened.
            Toast.makeText(
                    this@Binding,
                    R.string.remote_service_disconnected,
                    Toast.LENGTH_SHORT
            ).show()
        }
    }

    /**
     * Class for interacting with the secondary interface of the service.
     */
    private val secondaryConnection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // Connecting to a secondary interface is the same as any
            // other interface.
            secondaryService = ISecondary.Stub.asInterface(service)
            killButton.isEnabled = true
        }

        override fun onServiceDisconnected(className: ComponentName) {
            secondaryService = null
            killButton.isEnabled = false
        }
    }

    private val mBindListener = View.OnClickListener {
        // Establish a couple connections with the service, binding
        // by interface names. This lets other applications be
        // installed that replace the remote service by implementing
        // the same interface.
        val intent = Intent(this@Binding, RemoteService::class.java)
        intent.action = IRemoteService::class.java.name
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
        intent.action = ISecondary::class.java.name
        bindService(intent, secondaryConnection, Context.BIND_AUTO_CREATE)
        isBound = true
        callbackText.text = "Binding."
    }

    private val unbindListener = View.OnClickListener {
        if (isBound) {
            // If we have received the service, and hence registered with
            // it, then now is the time to unregister.
            try {
                mService?.unregisterCallback(mCallback)
            } catch (e: RemoteException) {
                // There is nothing special we need to do if the service
                // crashes.
            }

            // Detach our existing connection.
            unbindService(mConnection)
            unbindService(secondaryConnection)
            killButton.isEnabled = false
            isBound = false
            callbackText.text = "Unbinding."
        }
    }

    private val killListener = View.OnClickListener {
        // To kill the process hosting the service, we need to know its
        // PID.  Conveniently, the service has a call that returns
        // that information.
        try {
            secondaryService?.pid?.also { pid ->
                // Note that, though this API lets us request to
                // kill any process based on its PID, the kernel
                // still imposes standard restrictions on which PIDs you
                // can actually kill. Typically this means only
                // the process running your application and any additional
                // processes created by that app, as shown here. Packages
                // sharing a common UID are also able to kill each
                // other's processes.
                Process.killProcess(pid)
                callbackText.text = "Killed service process."
            }
        } catch (ex: RemoteException) {
            // Recover gracefully from the process hosting the
            // server dying.
            // For purposes of this sample, put up a notification.
            Toast.makeText(this@Binding, R.string.remote_call_failed, Toast.LENGTH_SHORT).show()
        }
    }

    // ----------------------------------------------------------------------
    // Code showing how to deal with callbacks.
    // ----------------------------------------------------------------------

    /**
     * This implementation is used to receive callbacks from the remote
     * service.
     */
    private val mCallback = object : IRemoteServiceCallback.Stub() {
        /**
         * This is called by the remote service regularly to tell us about
         * new values.  Note that IPC calls are dispatched through a thread
         * pool running in each process, so the code executing here is
         * NOT running in our main thread like most other things. So,
         * to update the UI, we need to use a Handler to hop over there.
         */
        override fun valueChanged(value: Int) {
            handler.sendMessage(handler.obtainMessage(BUMP_MSG, value, 0))
        }
    }

    /**
     * Standard initialization of this activity.  Set up the UI, then wait
     * for the user to interact with it before doing anything.
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContentView(R.layout.remote_service_binding)

        // Watch for button taps.
        var button: Button = findViewById(R.id.bind)
        button.setOnClickListener(mBindListener)
        button = findViewById(R.id.unbind)
        button.setOnClickListener(unbindListener)
        killButton = findViewById(R.id.kill)
        killButton.setOnClickListener(killListener)
        killButton.isEnabled = false

        callbackText = findViewById(R.id.callback)
        callbackText.text = "Not attached."
        handler = InternalHandler(callbackText)
    }

    private class InternalHandler(
            textView: TextView,
            private val weakTextView: WeakReference<TextView> = WeakReference(textView)
    ) : Handler() {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                BUMP_MSG -> weakTextView.get()?.text = "Received from service: ${msg.arg1}"
                else -> super.handleMessage(msg)
            }
        }
    }
}