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

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

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

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

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

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

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

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

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

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

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

    นอกจากนี้ยังมีตัวเลือกในการสร้างไลบรารี Kotlin หรือ Java ซึ่งจะสร้างไฟล์ JAR แบบดั้งเดิม แม้ว่าไฟล์ JAR จะมีประโยชน์สำหรับโปรเจ็กต์หลายโปรเจ็กต์ โดยเฉพาะเมื่อคุณต้องการแชร์โค้ดกับแพลตฟอร์มอื่นๆ แต่ไฟล์ JAR จะไม่อนุญาตให้คุณรวมทรัพยากรหรือไฟล์ Manifest ของ Android ซึ่งมีประโยชน์มากสำหรับการนำโค้ดมาใช้ซ้ำในโปรเจ็กต์ 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 ลงในโปรเจ็กต์ ส่วนต่อไปนี้อธิบายวิธีใช้กล่องโต้ตอบเพื่อเพิ่มข้อกําหนด

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

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

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

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

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

  5. เลือกการกําหนดค่าที่จําเป็นต้องใช้ทรัพยากรนี้ หรือเลือกการใช้งานหากใช้กับการกําหนดค่าทั้งหมด แล้วคลิกตกลง

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

Groovy

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

Kotlin

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

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

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

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

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

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

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

    เพิ่มการพึ่งพา 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 มากที่สุด)

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

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

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

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

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

  • โมดูลไลบรารีอาจใช้ไลบรารี JAR ภายนอกได้

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

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

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

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

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

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

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

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

    หากมีโปรเจ็กต์ไลบรารีที่คุณใช้สร้างและเผยแพร่ AAR คุณสามารถเพิ่มไฟล์การกําหนดค่า ProGuard ลงในการกำหนดค่าบิลด์ของไลบรารีได้ หากทำเช่นนั้น ปลั๊กอิน Gradle ของ Android จะใช้กฎ 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 รายการ