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

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

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

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

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

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

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

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

สร้างโมดูลคลัง

หากต้องการสร้างโมดูลไลบรารีใหม่ในโครงการ ให้ทำดังนี้

1. คลิกไฟล์ > ใหม่ > โมดูลใหม่
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 {
         id 'com.android.application'
     }
     

   Kotlin

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

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

   ดึงดูด

     plugins {
         id 'com.android.library'
     }
     

   Kotlin

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

4. บันทึกไฟล์และคลิกไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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 แล้วเลือกการกำหนดค่าที่ทรัพยากร Dependency นำไปใช้ได้ หากไลบรารีควรใช้ได้กับการกำหนดค่าทั้งหมด ให้เลือก การใช้งาน

   

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

   ดึงดูด

     implementation files('my_path/my_lib.aar')
   

   Kotlin

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

วิธีนำเข้าทรัพยากร Dependency ของบิลด์ Gradle นอก Android Studio มีดังนี้ เพิ่มเส้นทางไปยังการอ้างอิงใน ไฟล์ 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"))))
}

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

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

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

หากต้องการประกาศทรัพยากรสาธารณะ ให้เพิ่มการประกาศ <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)

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

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

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

  อย่างไรก็ตาม หากโปรเจ็กต์มีโมดูลไลบรารีที่แอปใช้งาน โมดูลแอปจะถือว่าทรัพยากร 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 ของไลบรารี ไฟล์:

  ดึงดูด

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

  Kotlin

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

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

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

  ความแตกต่างที่สำคัญคือไลบรารีและการอ้างอิงของไลบรารี รวมเป็นทรัพยากร 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/ สำหรับการส่งออกโฆษณาเนทีฟ คลัง