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

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

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

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

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

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

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

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

ดึงดูด

  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. ในแท็บประกาศการพึ่งพา ให้คลิก แล้วเลือกการพึ่งพา Jar ในเมนู

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

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

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

    ดึงดูด

      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 ของไลบรารีและการอ้างอิงทั้งหมดของ APK ด้วย เนื่องจากไม่มีแอปแยกต่างหากที่อยู่ระหว่างการทดสอบ งาน androidTest จะติดตั้ง (และถอนการติดตั้ง) เฉพาะ APK ทดสอบเท่านั้น

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

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

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

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