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

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

อย่างไรก็ตาม ไลบรารี 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 Script
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 ลงในโปรเจ็กต์ได้ ส่วนต่อไปนี้จะอธิบายวิธีใช้กล่องโต้ตอบเพื่อเพิ่ม การอ้างอิง

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

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

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

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

   

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

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

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

  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 ของแอปเพื่อยืนยันว่ามีการประกาศที่คล้ายกับต่อไปนี้ (ขึ้นอยู่กับการกำหนดค่าบิลด์ที่คุณเลือก)

  implementation 'com.example:examplelibrary:1.0.0'

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

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

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

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

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

   

   ตรวจสอบไฟล์ 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 ของแอป เช่น

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

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 รายการได้ด้วย

• /classes.jar
• /res/
• /R.txt
• /public.txt
• /assets/
• /libs/name.jar
• /jni/abi_name/name.so (โดย abi_name เป็นหนึ่งใน ABI ที่ Android รองรับ)
• /proguard.txt
• /lint.jar
• /api.jar
• /prefab/ สำหรับการส่งออกไลบรารี เนทีฟ