สร้างไลบรารี 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

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

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

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

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

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

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

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

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

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

Groovy

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

Kotlin

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

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

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

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

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

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

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

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

  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. ไปที่ไฟล์ > โครงสร้างโปรเจ็กต์ > การอ้างอิง
  2. ในแท็บการอ้างอิงที่ประกาศ ให้คลิก แล้วเลือกการอ้างอิง Jar ในเมนู

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

    เพิ่มทรัพยากร 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)

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

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

    เมื่อเพิ่มทรัพยากร 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 รายการได้ด้วย