สร้างไลบรารี Android

ไลบรารี Android มีโครงสร้างเหมือนกับโมดูลแอป Android ซึ่งมีทุกอย่างที่จำเป็นในการสร้างแอป รวมถึงซอร์สโค้ด ไฟล์ทรัพยากร และ Android Manifest

อย่างไรก็ตาม ไลบรารี Android จะคอมไพล์เป็นไฟล์ Android Archive (AAR) ที่คุณใช้เป็นทรัพยากร Dependency สำหรับโมดูลแอป Android ได้ แทนที่จะคอมไพล์เป็น APK ที่ทำงานบนอุปกรณ์ ไฟล์ AAR มีฟังก์ชันการทำงานต่อไปนี้สำหรับแอป Android ซึ่งแตกต่างจากไฟล์ JAR

  • ไฟล์ AAR สามารถมีทรัพยากร Android และไฟล์ Manifest ซึ่งช่วยให้คุณรวมทรัพยากรที่ใช้ร่วมกัน เช่น เลย์เอาต์และ Drawable ไว้ด้วยกันได้ นอกเหนือจากคลาสและเมธอด Kotlin หรือ Java
  • ไฟล์ AAR สามารถมีไลบรารี C/C++ เพื่อให้โค้ด C/C++ ของโมดูลแอปใช้งานได้

โมดูลคลังมีประโยชน์ในสถานการณ์ต่อไปนี้

  • เมื่อสร้างแอปหลายแอปที่ใช้คอมโพเนนต์บางอย่างเหมือนกัน เช่น กิจกรรม บริการ หรือเลย์เอาต์ UI
  • เมื่อสร้างแอปที่มี APK หลายรูปแบบ เช่น เวอร์ชันฟรีและเวอร์ชันที่ต้องชำระเงิน ซึ่งใช้คอมโพเนนต์หลักร่วมกัน

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

หน้านี้อธิบายวิธีสร้างและใช้โมดูลไลบรารี Android ดูคำแนะนำเกี่ยวกับวิธีเผยแพร่ไลบรารีได้ที่ เผยแพร่ไลบรารี

สร้างโมดูลไลบรารี

หากต้องการสร้างโมดูลไลบรารีใหม่ในโปรเจ็กต์ ให้ทำดังนี้

  1. คลิก File > New > New Module
  2. ในกล่องโต้ตอบสร้างโมดูลใหม่ที่ปรากฏขึ้น ให้คลิกไลบรารี Android แล้วคลิกถัดไป

    นอกจากนี้ยังมีตัวเลือกในการสร้างไลบรารี Kotlin หรือ Java ซึ่งจะสร้างไฟล์ JAR แบบดั้งเดิม แม้ว่าไฟล์ JAR จะมีประโยชน์สำหรับโปรเจ็กต์จำนวนมาก โดยเฉพาะอย่างยิ่งเมื่อคุณต้องการแชร์โค้ดกับแพลตฟอร์มอื่นๆ แต่ก็ไม่สามารถรวมทรัพยากร Android หรือไฟล์ Manifest ซึ่งมีประโยชน์อย่างยิ่งสำหรับการนำโค้ดกลับมาใช้ซ้ำในโปรเจ็กต์ Android คู่มือนี้ มุ่งเน้นที่การสร้างไลบรารี Android

  3. ตั้งชื่อไลบรารีและเลือก SDK เวอร์ชันขั้นต่ำสำหรับโค้ดในไลบรารี จากนั้นคลิกเสร็จสิ้น

เมื่อการซิงค์โปรเจ็กต์ Gradle เสร็จสมบูรณ์แล้ว โมดูลไลบรารีจะปรากฏในแผงโปรเจ็กต์ หากไม่เห็นโฟลเดอร์โมดูลใหม่ ให้ตรวจสอบว่าบานหน้าต่างแสดงมุมมอง Android

แปลงโมดูลแอปเป็นโมดูลไลบรารี

หากมีโมดูลแอปที่มีอยู่ซึ่งมีโค้ดที่ต้องการนำกลับมาใช้ใหม่ คุณสามารถเปลี่ยนโมดูลดังกล่าวให้เป็นโมดูลไลบรารีได้โดยทำดังนี้

  1. เปิดไฟล์ build.gradle ระดับโมดูล หากคุณใช้ Groovy หรือไฟล์ build.gradle.kts หากคุณใช้สคริปต์ Kotlin
  2. ลบบรรทัดสำหรับ applicationId มีเพียงโมดูลแอป Android เท่านั้นที่กำหนดค่านี้ได้
  3. ค้นหาบล็อก `plugins` ที่ด้านบนของไฟล์ซึ่งมีลักษณะดังนี้

    Groovy

      plugins {
      id 'com.android.application'
  }

    Kotlin

      plugins {
      id("com.android.application")
  }

    เปลี่ยนเป็นค่าต่อไปนี้

    Groovy

      plugins {
      id 'com.android.library'
  }

    Kotlin

      plugins {
      id("com.android.library")
  }
  4. บันทึกไฟล์แล้วคลิกไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

โครงสร้างของโมดูลยังคงเหมือนเดิม แต่ตอนนี้จะ ทำงานเป็นไลบรารี Android การสร้างจะสร้างไฟล์ AAR แทนที่จะเป็น APK

เมื่อต้องการสร้างไฟล์ AAR ให้เลือกโมดูลไลบรารีในหน้าต่างโปรเจ็กต์ แล้วคลิกสร้าง > สร้าง APK

เพิ่มทรัพยากร Dependency ด้วยกล่องโต้ตอบโครงสร้างโปรเจ็กต์

คุณใช้กล่องโต้ตอบโครงสร้างโปรเจ็กต์เพื่อเพิ่มทรัพยากร Dependency ลงในโปรเจ็กต์ได้ ส่วนต่อไปนี้จะอธิบายวิธีใช้กล่องโต้ตอบเพื่อเพิ่ม การอ้างอิง

ใช้ไลบรารีจากภายในโปรเจ็กต์เดียวกัน

หากต้องการใช้โค้ดของไลบรารี Android ใหม่ในแอปหรือโมดูลไลบรารีอื่นภายในโปรเจ็กต์เดียวกัน ให้เพิ่มทรัพยากร Dependency ระดับโปรเจ็กต์ดังนี้

  1. ไปที่ไฟล์ > โครงสร้างโปรเจ็กต์  > ทรัพยากร Dependency
  2. เลือกโมดูลที่ต้องการเพิ่มไลบรารี
  3. ในแท็บการขึ้นต่อกันที่ประกาศ ให้คลิก แล้วเลือก การขึ้นต่อกันของโมดูลจากเมนู

  4. ในกล่องโต้ตอบเพิ่มการอ้างอิงโมดูล ให้เลือกโมดูลไลบรารี

    เพิ่มทรัพยากร Dependency ของโมดูลในกล่องโต้ตอบโครงสร้างโปรเจ็กต์

  5. เลือกการกำหนดค่าที่ต้องใช้การอ้างอิงนี้ หรือเลือกการติดตั้งใช้งานหากใช้กับการกำหนดค่าทั้งหมด จากนั้นคลิกตกลง

Android Studio จะแก้ไขไฟล์ build.gradle หรือ build.gradle.kts ของโมดูลเพื่อ เพิ่มทรัพยากร Dependency ในรูปแบบต่อไปนี้

Groovy

  implementation project(path: ":example-library")

Kotlin

  implementation(project(":example-library"))

ใช้ไลบรารีในโปรเจ็กต์อื่นๆ

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

เมื่อเผยแพร่ไลบรารี Android ไปยังที่เก็บ Maven ระบบจะรวมข้อมูลเมตาเพื่อให้รวมทรัพยากร Dependency ของไลบรารีไว้ในบิลด์ที่ใช้ ซึ่งจะช่วยให้ระบบขจัดข้อมูลที่ซ้ำกันในไลบรารีโดยอัตโนมัติได้หากมีการใช้ในหลายที่

หากต้องการใช้โค้ดของไลบรารี Android ในโมดูลแอปอื่นในโปรเจ็กต์อื่น ให้ทำดังนี้

  1. ไปที่ File > Project Structure > Dependencies
  2. ในแท็บการอ้างอิงที่ประกาศ ให้คลิก แล้วเลือก การอ้างอิงไลบรารีในเมนู

  3. ในกล่องโต้ตอบเพิ่มการอ้างอิงไลบรารี ให้ใช้ช่องค้นหาเพื่อค้นหา ไลบรารีที่จะเพิ่ม แบบฟอร์มนี้จะค้นหาระเบียบวิธีที่ระบุใน ในบล็อก dependencyResolutionManagement { repositories {...}} ในไฟล์ settings.gradle หรือ settings.gradle.kts

    เพิ่มทรัพยากร Dependency ของไลบรารีในกล่องโต้ตอบโครงสร้างโปรเจ็กต์

  4. เลือกการกำหนดค่าที่ต้องใช้การอ้างอิงนี้ หรือเลือกการติดตั้งใช้งานหากใช้กับการกำหนดค่าทั้งหมด จากนั้นคลิกตกลง

ตรวจสอบไฟล์ build.gradle หรือ build.gradle.kts ของแอปเพื่อยืนยันว่ามีการประกาศที่คล้ายกับต่อไปนี้ (ขึ้นอยู่กับการกำหนดค่าบิลด์ที่คุณเลือก)

Groovy

  implementation 'com.example:examplelibrary:1.0.0'

Kotlin

  implementation("com.example:examplelibrary:1.0.0")

เพิ่ม AAR หรือ JAR เป็นทรัพยากร Dependency

หากต้องการใช้โค้ดของไลบรารี Android ในโมดูลแอปอื่น ให้ทำดังนี้

  1. ไปที่ไฟล์ > โครงสร้างโปรเจ็กต์ > ทรัพยากร Dependency
  2. ในแท็บการอ้างอิงที่ประกาศ ให้คลิก แล้วเลือกการอ้างอิง Jar ในเมนู

  3. ในกล่องโต้ตอบเพิ่มทรัพยากร Dependency ของ Jar/Aar ให้ป้อนเส้นทางไปยังไฟล์ AAR หรือ JAR จากนั้นเลือกการกำหนดค่าที่ใช้ทรัพยากร Dependency หากต้องการให้ไลบรารีพร้อมใช้งานสำหรับการกำหนดค่าทั้งหมด ให้เลือกการกำหนดค่าการติดตั้งใช้งาน

    เพิ่มทรัพยากร Dependency ของ AAR ในกล่องโต้ตอบโครงสร้างโปรเจ็กต์

    ตรวจสอบไฟล์ build.gradle หรือ build.gradle.kts ของแอปเพื่อยืนยันว่ามีประกาศที่คล้ายกับประกาศต่อไปนี้ (ขึ้นอยู่กับการกำหนดค่าบิลด์ที่คุณเลือก)

    Groovy

      implementation files('my_path/my_lib.aar')

    Kotlin

      implementation(files("my_path/my_lib.aar"))

หากต้องการนำเข้าทรัพยากร Dependency ในบิลด์ Gradle ที่ทำงานภายนอก Android Studio ให้ เพิ่มเส้นทางไปยังทรัพยากร Dependency ในไฟล์ build.gradle หรือ build.gradle.kts ของแอป เช่น

Groovy

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar", "*.aar"])
}

Kotlin

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
}

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่มการพึ่งพา Gradle ได้ที่เพิ่มการพึ่งพาบิลด์

ประกาศทรัพยากรสาธารณะ

ทรัพยากรรวมถึงไฟล์ทั้งหมดในไดเรกทอรี res/ ของโปรเจ็กต์ เช่น รูปภาพ ทรัพยากรทั้งหมดในไลบรารีจะเป็นแบบสาธารณะโดยค่าเริ่มต้น หากต้องการทำให้ทรัพยากรทั้งหมดเป็นแบบส่วนตัวโดยนัย คุณต้องกำหนดแอตทริบิวต์ที่เฉพาะเจาะจงอย่างน้อย 1 รายการเป็นแบบสาธารณะ

หากต้องการประกาศทรัพยากรสาธารณะ ให้เพิ่ม<public>การประกาศ ลงในไฟล์ public.xml ของไลบรารี หากยังไม่ได้เพิ่มทรัพยากรสาธารณะ คุณจะต้องสร้างไฟล์ public.xml ในไดเรกทอรี res/values/ ของไลบรารี

โค้ดตัวอย่างต่อไปนี้สร้างทรัพยากรสตริงสาธารณะ 2 รายการที่มีชื่อ mylib_app_name และ mylib_public_string

<resources>
    <public name="mylib_app_name" type="string"/>
    <public name="mylib_public_string" type="string"/>
</resources>

หากต้องการป้องกันไม่ให้ผู้ใช้ในคลังเข้าถึงทรัพยากรที่มีไว้สำหรับใช้ภายในเท่านั้น ให้ใช้กลไกการกำหนดแบบส่วนตัวอัตโนมัตินี้โดยประกาศทรัพยากรสาธารณะอย่างน้อย 1 รายการ หรือจะทำให้ ทรัพยากรทั้งหมดเป็นแบบส่วนตัวโดยเพิ่มแท็ก <public /> ที่ว่างเปล่าก็ได้ คำสั่งนี้ ไม่ได้ทำเครื่องหมายสิ่งใดเป็นสาธารณะและทำให้ทรัพยากรทั้งหมดเป็นส่วนตัว

หากต้องการให้ทรัพยากรยังคงแสดงต่อ นักพัฒนาแอปที่ใช้ไลบรารีของคุณ คุณควรตั้งค่าให้เป็นแบบสาธารณะ

การทําให้แอตทริบิวต์เป็นแบบส่วนตัวโดยนัยจะป้องกันไม่ให้ผู้ใช้ไลบรารีของคุณ รับคําแนะนําการเติมโค้ดจากทรัพยากรไลบรารีภายใน และช่วยให้ผู้ใช้เปลี่ยนชื่อหรือนําทรัพยากรส่วนตัวออกได้โดยไม่ทําให้ ไคลเอ็นต์ของไลบรารีของคุณใช้งานไม่ได้ ระบบจะกรองทรัพยากรส่วนตัวออกจากการเติมโค้ดอัตโนมัติ และเครื่องมือ Lint จะเตือนคุณเมื่อพยายาม อ้างอิงทรัพยากรส่วนตัว

เมื่อสร้างไลบรารี ปลั๊กอิน Android Gradle จะรับคำจำกัดความของทรัพยากรสาธารณะ และแตกไฟล์เหล่านั้นลงในไฟล์ public.txt ซึ่งจะ ได้รับการแพ็กเกจภายในไฟล์ AAR

ข้อควรพิจารณาในการพัฒนาสำหรับโมดูลไลบรารี

ขณะพัฒนาโมดูลไลบรารีและแอปที่ขึ้นอยู่กับไลบรารี โปรดทราบลักษณะการทำงานและข้อจำกัดต่อไปนี้

  • ระบบจะผสานรวมคลังตามลำดับความสำคัญ

    เมื่อเพิ่มการอ้างอิงไปยังโมดูลไลบรารีในโมดูลแอป Android แล้ว คุณจะตั้งค่าลำดับความสำคัญที่เกี่ยวข้องได้ ในเวลาบิลด์ ระบบจะผสานรวมไลบรารีกับแอปทีละรายการ โดยเริ่มจากลำดับความสำคัญต่ำสุดไปสูงสุด

    การอ้างอิงทรัพยากรในไลบรารีจะอ้างอิงถึงทรัพยากรที่ผสาน ไม่ใช่ทรัพยากรของไลบรารีเสมอไป โมดูลไลบรารีบังคับการใช้ทรัพยากรของตัวเองกับทรัพยากรของแอปหรือไลบรารีอื่นๆ ไม่ได้เมื่อมีทรัพยากรที่มีชื่อเดียวกัน

  • หลีกเลี่ยงความขัดแย้งในการผสานทรัพยากร

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

    หากเกิดความขัดแย้งระหว่างไลบรารี AAR หลายรายการ ระบบจะใช้ทรัพยากรจากไลบรารีที่แสดงเป็นรายการแรกในรายการทรัพยากร Dependency (ใกล้กับด้านบนของบล็อก dependencies)

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

  • ในการสร้างแบบหลายโมดูล ระบบจะถือว่าทรัพยากร Dependency ของ JAR เป็น ทรัพยากร Dependency ที่ส่งผ่าน

    เมื่อเพิ่มทรัพยากร Dependency ของ JAR ลงในโปรเจ็กต์ไลบรารีที่เอาต์พุตเป็น AAR โมดูลไลบรารีจะประมวลผล JAR และแพ็กเกจด้วย AAR

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

    ความขัดแย้งของทรัพยากร Java ที่เกิดจากทรัพยากร Dependency JAR ในเครื่องต้องได้รับการแก้ไข ในโมดูลแอปที่ใช้ไลบรารี

  • โมดูลไลบรารีสามารถขึ้นอยู่กับไลบรารี JAR ภายนอกได้

    คุณสามารถพัฒนาโมดูลไลบรารีที่ขึ้นอยู่กับไลบรารีภายนอกได้ ในกรณีนี้ โมดูลที่ขึ้นต่อกันต้องสร้าง เทียบกับเป้าหมายที่มีไลบรารีภายนอก

    โปรดทราบว่าทั้งโมดูลไลบรารีและแอปที่ขึ้นอยู่กับไลบรารีต้อง ประกาศไลบรารีภายนอกในไฟล์ Manifest ในองค์ประกอบ <uses-library>

  • minSdkVersion ของโมดูลแอปต้องเท่ากับหรือ มากกว่าเวอร์ชันที่กำหนดโดยไลบรารี

    ไลบรารีจะคอมไพล์เป็นส่วนหนึ่งของโมดูลแอปที่ขึ้นต่อกัน ดังนั้น API ที่ใช้ในโมดูลไลบรารีต้องเข้ากันได้กับเวอร์ชันแพลตฟอร์มที่โมดูลแอปรองรับ

  • โมดูลไลบรารีแต่ละโมดูลจะสร้างคลาส R ของตัวเอง

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

    ระบบจะสร้างคลาส R ที่สร้างจากโมดูลหลักและโมดูลไลบรารี ในแพ็กเกจทั้งหมดที่จำเป็น ซึ่งรวมถึงแพ็กเกจของโมดูลหลัก และแพ็กเกจของไลบรารี

  • โมดูลไลบรารีอาจมีไฟล์การกำหนดค่า ProGuard ของตัวเอง

    หากมีโปรเจ็กต์ไลบรารีที่ใช้สร้างและเผยแพร่ AAR คุณจะเพิ่มไฟล์กำหนดค่า ProGuard ลงในการกำหนดค่าบิลด์ของไลบรารีได้ หากคุณทำเช่นนั้น ปลั๊กอิน Android Gradle จะใช้กฎ ProGuard ที่คุณระบุ เครื่องมือบิลด์จะฝังไฟล์นี้ไว้ในไฟล์ AAR ที่สร้างขึ้นสำหรับโมดูลไลบรารี เมื่อเพิ่มไลบรารีลงในโมดูลแอป ระบบจะผนวกไฟล์ ProGuard ของไลบรารี เข้ากับไฟล์กำหนดค่า ProGuard (proguard.txt) ของ โมดูลแอป

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

    หากต้องการเพิ่มกฎ ProGuard ลงในโปรเจ็กต์ไลบรารี ให้ระบุชื่อไฟล์ด้วยพร็อพเพอร์ตี้ consumerProguardFiles ภายในบล็อก defaultConfig ของไฟล์ build.gradle หรือ build.gradle.kts ของไลบรารี

    เช่น ข้อมูลโค้ดต่อไปนี้จะตั้งค่า lib-proguard-rules.txtเป็นไฟล์การกำหนดค่า ProGuard ของไลบรารี

    Groovy

    android {
    defaultConfig {
        consumerProguardFiles 'lib-proguard-rules.txt'
    }
    ...
}

    Kotlin

    android {
    defaultConfig {
        consumerProguardFiles("lib-proguard-rules.txt")
    }
    ...
}

    อย่างไรก็ตาม หากโมดูลไลบรารีเป็นส่วนหนึ่งของการสร้างแบบหลายโมดูลที่ คอมไพล์เป็น APK และไม่สร้าง AAR ให้เรียกใช้การลดขนาดโค้ด เฉพาะในโมดูลแอปที่ใช้ไลบรารี ดูข้อมูลเพิ่มเติม เกี่ยวกับกฎ ProGuard และการใช้งานได้ที่ ลดขนาด ปรับให้ยากต่อการอ่าน และเพิ่มประสิทธิภาพ แอป

  • การทดสอบโมดูลไลบรารีแทบจะเหมือนกับ การทดสอบแอป

    ความแตกต่างหลักคือระบบจะรวมไลบรารีและทรัพยากร Dependency ของไลบรารีนั้นเป็นทรัพยากร Dependency ของ APK ทดสอบโดยอัตโนมัติ ซึ่งหมายความว่า APK ทดสอบไม่ได้มีเพียงโค้ดของตัวเองเท่านั้น แต่ยังมี AAR ของไลบรารี และทรัพยากร Dependency ทั้งหมดด้วย เนื่องจากไม่มีแอปแยกต่างหากภายใต้การทดสอบ androidTest งานจึงติดตั้ง (และถอนการติดตั้ง) เฉพาะ APK ทดสอบ

    เมื่อผสาน ไฟล์ Manifest หลายไฟล์ Gradle จะทำตามลำดับความสำคัญเริ่มต้นและ ผสานไฟล์ Manifest ของไลบรารีเข้ากับไฟล์ Manifest หลักของ APK ทดสอบ

โครงสร้างของไฟล์ AAR

นามสกุลไฟล์ AAR คือ .aar และประเภทอาร์ติแฟกต์ Maven คือ aar ตัวไฟล์เป็นไฟล์ ZIP รายการที่ต้องระบุมีเพียง /AndroidManifest.xml

ไฟล์ AAR ยังมีรายการที่ไม่บังคับต่อไปนี้อย่างน้อย 1 รายการได้ด้วย