หน้านี้ได้รับการแปลโดย Cloud Translation API

เพิ่มการพึ่งพิงบิวด์

ระบบบิลด์ Gradle ใน Android Studio ช่วยให้คุณรวมไบนารีภายนอกหรือ โมดูลไลบรารีอื่นๆ ไว้ในบิลด์เป็นทรัพยากร Dependency ได้ โดยขึ้นอยู่กับว่าอยู่ที่เครื่องของคุณหรือในที่เก็บข้อมูลระยะไกล และระบบจะรวมการอ้างอิงแบบทรานซิทีฟที่ประกาศไว้โดยอัตโนมัติด้วย หน้านี้ อธิบายวิธีใช้ทรัพยากร Dependency กับโปรเจ็กต์ Android รวมถึงรายละเอียด เกี่ยวกับลักษณะการทำงานและการกำหนดค่าที่เฉพาะเจาะจงกับ Android Gradle Plugin (AGP) ดูคำแนะนำเชิงแนวคิดเกี่ยวกับทรัพยากร Dependency ของ Gradle เพิ่มเติมได้ในคำแนะนำ Gradle สำหรับการจัดการทรัพยากร Dependency แต่โปรดทราบว่าโปรเจ็กต์ Android ต้องใช้เฉพาะการกำหนดค่าทรัพยากร Dependency ที่กำหนดไว้ในหน้านี้เท่านั้น

เพิ่มทรัพยากร Dependency ของไลบรารีหรือปลั๊กอิน

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

ดูคำแนะนำเกี่ยวกับการเพิ่มและจัดการทรัพยากร Dependency เนทีฟ (ไม่พบบ่อย) ได้ที่ ทรัพยากร Dependency เนทีฟ

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

เพิ่มนามแฝงสำหรับเวอร์ชันของทรัพยากร Dependency ที่ต้องการในส่วน [versions]ของไฟล์แคตตาล็อกเวอร์ชันที่ชื่อ libs.versions.toml (ในไดเรกทอรี gradle ในมุมมองโปรเจ็กต์หรือสคริปต์ Gradle ในมุมมอง Android)
```
[versions]
agp = "8.3.0"
androidx-macro-benchmark = "1.2.2"
my-library = "1.4"

[libraries]
...

[plugins]
...
```
นามแฝงมีขีดกลางหรือขีดล่างได้ โดยชื่อแทนเหล่านี้จะสร้างค่าที่ซ้อนกัน ซึ่งคุณอ้างอิงได้ในสคริปต์บิลด์ การอ้างอิงจะเริ่มต้นด้วยชื่อของ แคตตาล็อก ซึ่งเป็นส่วนหนึ่งของ libs.versions.tomllibs เมื่อ ใช้แคตตาล็อกเวอร์ชันเดียว เราขอแนะนำให้คงค่าเริ่มต้นเป็น "libs"
เพิ่มนามแฝงสำหรับการอ้างอิงในส่วน [libraries] (สำหรับ ไบนารีระยะไกลหรือโมดูลไลบรารีในเครื่อง) หรือ [plugins] (สำหรับ ปลั๊กอิน) ของไฟล์ libs.versions.toml
```
[versions]
...

[libraries]
androidx-benchmark-macro = { group = "androidx.benchmark", name = "benchmark-macro-junit4", version.ref = "androidx-macro-benchmark" }
my-library = { group = "com.myapplication", name = "mylibrary", version.ref = "my-library" }

[plugins]
androidApplication = { id = "com.android.application", version.ref = "agp" }
```
ไลบรารีบางรายการมีอยู่ในรายการวัสดุ (BOM) ที่เผยแพร่แล้ว ซึ่ง จัดกลุ่มตระกูลของไลบรารีและเวอร์ชันของไลบรารี คุณสามารถรวม BOM ไว้ใน แคตตาล็อกเวอร์ชันและไฟล์บิลด์ แล้วให้ BOM จัดการเวอร์ชันเหล่านั้นให้คุณ ดูรายละเอียดได้ที่การใช้รายการวัสดุ
เพิ่มการอ้างอิงไปยังนามแฝงของการพึ่งพาในสคริปต์บิลด์ของโมดูลที่ต้องมีการพึ่งพา แปลงขีดล่างและขีดกลางของชื่อแทน เป็นจุดเมื่ออ้างอิงจากสคริปต์บิลด์ สคริปต์บิลด์ระดับโมดูล จะมีลักษณะดังนี้
Kotlin
plugins { alias(libs.plugins.androidApplication) } dependencies { implementation(libs.androidx.benchmark.macro) implementation(libs.my.library) }
Groovy
plugins { alias 'libs.plugins.androidApplication' } dependencies { implementation libs.androidx.benchmark.macro implementation libs.my.library }
การอ้างอิงปลั๊กอินจะมี plugins ต่อท้ายชื่อแคตตาล็อก และ การอ้างอิงเวอร์ชันจะมี versions ต่อท้ายชื่อแคตตาล็อก (การอ้างอิงเวอร์ชัน ไม่ค่อยพบ โปรดดูตัวอย่างการอ้างอิงเวอร์ชันในการอ้างอิง ที่มีหมายเลขเวอร์ชันเดียวกัน) การอ้างอิงไลบรารี ไม่มีตัวระบุ libraries คุณจึงใช้ versions หรือ plugins ที่จุดเริ่มต้นของนามแฝงไลบรารี ไม่ได้

กำหนดค่าทรัพยากร Dependency

ภายในบล็อก dependencies คุณสามารถประกาศการขึ้นต่อกันของไลบรารีโดยใช้การกำหนดค่าการขึ้นต่อกันหลายแบบ (เช่น implementation ที่แสดง ก่อนหน้านี้) การกำหนดค่าการขึ้นต่อกันแต่ละรายการจะให้คำสั่งที่แตกต่างกันแก่ Gradle เกี่ยวกับวิธีใช้การขึ้นต่อกัน ตารางต่อไปนี้อธิบายการกำหนดค่าแต่ละรายการที่คุณใช้สำหรับ Dependency ในโปรเจ็กต์ Android ได้

การกำหนดค่า	ลักษณะการทำงาน
`implementation`	Gradle จะเพิ่มทรัพยากร Dependency ลงในเส้นทางคลาสการคอมไพล์และ แพ็กเกจทรัพยากร Dependency ลงในเอาต์พุตบิลด์ เมื่อโมดูลกำหนดค่า`implementation`การอ้างอิง จะเป็นการแจ้งให้ Gradle ทราบว่าคุณไม่ต้องการให้โมดูลรั่วไหลการอ้างอิงไปยังโมดูลอื่นๆ ในเวลาคอมไพล์ กล่าวคือ ระบบจะไม่ทำให้โมดูลอื่นๆ ที่ขึ้นอยู่กับโมดูลปัจจุบัน ใช้ทรัพยากร Dependency ได้ การใช้การกำหนดค่าการขึ้นต่อกันนี้แทน `api` อาจช่วยลดเวลาบิลด์ได้อย่างมาก เนื่องจากจะลดจำนวนโมดูลที่ระบบบิลด์ต้อง คอมไพล์ใหม่ ตัวอย่างเช่น หากการอ้างอิง `implementation` เปลี่ยน API ของตัวเอง Gradle จะคอมไพล์การอ้างอิงนั้นอีกครั้ง และคอมไพล์โมดูลที่ขึ้นอยู่กับการอ้างอิงนั้นโดยตรง โมดูลแอปและโมดูลทดสอบส่วนใหญ่ควรใช้การกำหนดค่านี้
`api`	Gradle จะเพิ่มทรัพยากร Dependency ลงใน classpath ของการคอมไพล์และเอาต์พุตของบิลด์ เมื่อโมดูลมีทรัพยากร Dependency `api` จะเป็นการแจ้งให้ Gradle ทราบว่าโมดูลต้องการส่งออกทรัพยากร Dependency นั้นไปยังโมดูลอื่นๆ โดยอ้อม เพื่อให้โมดูลอื่นๆ ใช้ทรัพยากร Dependency นั้นได้ทั้งในรันไทม์และเวลาคอมไพล์ ใช้การกำหนดค่านี้ด้วยความระมัดระวังและใช้เฉพาะกับการขึ้นต่อกันที่คุณต้องส่งออกแบบทรานซิทีฟไปยังผู้ใช้ปลายทางอื่นๆ ที่อัปสตรีม หากการอ้างอิง `api` มีการเปลี่ยนแปลง API ภายนอก Gradle จะคอมไพล์โมดูลทั้งหมดที่มีสิทธิ์เข้าถึงการอ้างอิงนั้นอีกครั้งในเวลาคอมไพล์ การมี`api`การอ้างอิงจำนวนมากอาจ ทำให้เวลาในการสร้างเพิ่มขึ้นอย่างมาก หากไม่ต้องการแสดง API ของทรัพยากร Dependency ต่อโมดูลแยกต่างหาก โมดูลไลบรารีควรใช้ทรัพยากร Dependency `implementation` แทน
`compileOnly`	Gradle จะเพิ่มการอ้างอิงไปยัง classpath การคอมไพล์เท่านั้น (กล่าวคือ จะไม่เพิ่มลงในเอาต์พุตการสร้าง) ซึ่งจะเป็นประโยชน์เมื่อ คุณสร้างโมดูล Android และต้องการการอ้างอิงระหว่าง การคอมไพล์ แต่จะเลือกให้มีการอ้างอิงดังกล่าวในเวลาเรียกใช้หรือไม่ก็ได้ ตัวอย่างเช่น หากคุณใช้ไลบรารีที่มีเฉพาะคำอธิบายประกอบขณะคอมไพล์ ซึ่งโดยปกติจะใช้เพื่อสร้างโค้ดแต่ไม่ได้รวมไว้ในเอาต์พุตบิลด์ คุณก็ทำเครื่องหมายไลบรารีนั้นได้`compileOnly` หากใช้การกำหนดค่านี้ โมดูลไลบรารีต้องมี เงื่อนไขรันไทม์เพื่อตรวจสอบว่ามีการขึ้นต่อกันหรือไม่ และเปลี่ยนลักษณะการทำงานอย่างราบรื่นเพื่อให้ยังคง ทำงานได้แม้ว่าจะไม่มีการระบุการขึ้นต่อกัน ซึ่งจะช่วยลดขนาดของ แอปสุดท้ายโดยไม่เพิ่มการอ้างอิงชั่วคราวที่ไม่สำคัญ หมายเหตุ: คุณใช้การกำหนดค่า `compileOnly` กับทรัพยากร Dependency ของ Android Archive (AAR) ไม่ได้
`runtimeOnly`	Gradle จะเพิ่มการอ้างอิงลงในเอาต์พุตบิลด์เท่านั้น เพื่อใช้ ในระหว่างรันไทม์ กล่าวคือ ไม่ได้เพิ่มลงใน classpath ของการคอมไพล์ โดยปกติแล้วจะไม่ค่อยได้ใช้ใน Android แต่จะใช้กันทั่วไปในแอปพลิเคชันเซิร์ฟเวอร์ เพื่อใช้การบันทึก เช่น ไลบรารีอาจใช้ Logging API ที่ไม่มีการติดตั้งใช้งาน ผู้ใช้ไลบรารีนั้นสามารถเพิ่มเป็น`implementation`การอ้างอิงและรวม`runtimeOnly`การอ้างอิงสำหรับการติดตั้งใช้งานการบันทึกจริงเพื่อใช้ได้
`ksp kapt annotationProcessor`	การกำหนดค่าเหล่านี้จะจัดหาไลบรารีที่ประมวลผลคำอธิบายประกอบ และสัญลักษณ์อื่นๆ ในโค้ดก่อนที่จะคอมไพล์ โดยปกติแล้วเครื่องมือเหล่านี้จะ ตรวจสอบโค้ดหรือสร้างโค้ดเพิ่มเติม ซึ่งจะช่วยลดโค้ดที่คุณ ต้องเขียน หากต้องการเพิ่มการอ้างอิงดังกล่าว คุณต้องเพิ่มการอ้างอิงลงในคลาสพาธของโปรแกรมประมวลผลคำอธิบายประกอบโดยใช้การกำหนดค่า `ksp`, `kapt` หรือ `annotationProcessor` การใช้การกำหนดค่าเหล่านี้จะช่วยปรับปรุงประสิทธิภาพการสร้างโดยแยก classpath ของการคอมไพล์ออกจาก classpath ของ Annotation Processor หาก Gradle พบ ตัวประมวลผลคำอธิบายประกอบในเส้นทางการจัดประเภทการคอมไพล์ Gradle จะปิดใช้งาน การหลีกเลี่ยงการคอมไพล์ ซึ่งส่งผลเสียต่อเวลาในการสร้าง (Gradle 5.0 ขึ้นไปจะไม่สนใจตัวประมวลผลคำอธิบายประกอบที่พบในเส้นทางการจัดประเภทการคอมไพล์) ปลั๊กอิน Android Gradle จะถือว่าทรัพยากร Dependency เป็นตัวประมวลผลคำอธิบายประกอบ หากไฟล์ JAR มีไฟล์ต่อไปนี้ `META-INF/services/javax.annotation.processing.Processor` หากปลั๊กอินตรวจพบ Annotation Processor ที่อยู่ใน Compile Classpath ปลั๊กอินจะสร้างข้อผิดพลาดในการสร้าง `ksp` เป็นตัวประมวลผลสัญลักษณ์ Kotlin และคอมไพเลอร์ Kotlin จะเรียกใช้ `kapt` และ `apt` เป็นเครื่องมือแยกกันที่ ประมวลผลคำอธิบายประกอบก่อนที่คอมไพเลอร์ Kotlin หรือ Java จะดำเนินการ เมื่อตัดสินใจว่าจะใช้การกำหนดค่าใด ให้พิจารณาสิ่งต่อไปนี้ หากตัวประมวลผลพร้อมใช้งานเป็นตัวประมวลผลสัญลักษณ์ Kotlin ให้ใช้ เป็นทรัพยากร Dependency ของ `ksp` ดูรายละเอียดเกี่ยวกับการใช้ Kotlin Symbol Processor ได้ที่ย้ายข้อมูลจาก KAPT ไปยัง KSP หากโปรเซสเซอร์ไม่พร้อมใช้งานเป็น Kotlin Symbol Processor ให้ทำดังนี้ หากโปรเจ็กต์มีแหล่งที่มาของ Kotlin (แต่ก็อาจมีแหล่งที่มาของ Java ด้วย) ใช้ `kapt` เพื่อรวมแหล่งที่มา หากโปรเจ็กต์ใช้เฉพาะแหล่งที่มาของ Java ให้ใช้ `annotationProcessor` เพื่อรวมแหล่งที่มา ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้เครื่องมือประมวลผลคำอธิบายประกอบได้ที่ เพิ่มเครื่องมือประมวลผลคำอธิบายประกอบ
`lintChecks`	ใช้การกำหนดค่านี้เพื่อรวมไลบรารีที่มีการตรวจสอบ Lint ที่คุณต้องการให้ Gradle ดำเนินการเมื่อสร้างโปรเจ็กต์ แอป Android โปรดทราบว่า AAR ที่มีไฟล์ `lint.jar` จะ เรียกใช้การตรวจสอบที่กำหนดไว้ในไฟล์ `lint.jar` นั้นโดยอัตโนมัติ คุณจึงไม่จำเป็นต้องเพิ่มการอ้างอิง `lintChecks` อย่างชัดเจน ซึ่งช่วยให้คุณกำหนดไลบรารีและการตรวจสอบ Lint ที่เกี่ยวข้องในการอ้างอิงเดียวได้ เพื่อให้มั่นใจว่าการตรวจสอบจะทำงานเมื่อผู้ใช้ใช้ไลบรารีของคุณ
`lintPublish`	ใช้การกำหนดค่านี้ในโปรเจ็กต์ไลบรารี Android เพื่อรวมการตรวจสอบ Lint ที่คุณต้องการให้ Gradle คอมไพล์เป็นไฟล์ `lint.jar` และแพ็กเกจใน AAR ซึ่งทำให้โปรเจ็กต์ที่ใช้ AAR ของคุณใช้การตรวจสอบ Lint เหล่านั้นด้วย หากก่อนหน้านี้คุณใช้ การกำหนดค่าการขึ้นต่อกันของ `lintChecks` เพื่อรวมการตรวจสอบ Lint ใน AAR ที่เผยแพร่ คุณจะต้องย้ายข้อมูลการขึ้นต่อกันเหล่านั้น เพื่อใช้การกำหนดค่า `lintPublish` แทน Kotlin dependencies { // Executes lint checks from the ":checks" project at build time. lintChecks(project(":checks")) // Compiles lint checks from the ":checks-to-publish" into a // lint.jar file and publishes it to your Android library. lintPublish(project(":checks-to-publish")) } Groovy dependencies { // Executes lint checks from the ':checks' project at build time. lintChecks project(':checks') // Compiles lint checks from the ':checks-to-publish' into a // lint.jar file and publishes it to your Android library. lintPublish project(':checks-to-publish') }

กำหนดค่าการขึ้นต่อกันสำหรับตัวแปรของบิลด์ที่เฉพาะเจาะจง

การกำหนดค่าทั้งหมดข้างต้นจะใช้การขึ้นต่อกันกับตัวแปรบิลด์ทั้งหมด หากต้องการประกาศการขึ้นต่อกันสำหรับชุดแหล่งที่มาของตัวแปรบิลด์ที่เฉพาะเจาะจงเท่านั้น หรือสำหรับชุดแหล่งที่มาสำหรับการทดสอบ คุณต้องใช้ตัวพิมพ์ใหญ่สำหรับชื่อการกำหนดค่า และนำหน้าด้วยชื่อของตัวแปรบิลด์หรือชุดแหล่งที่มาสำหรับการทดสอบ

เช่น หากต้องการเพิ่มการอ้างอิงไบนารีระยะไกลเฉพาะในผลิตภัณฑ์ "ฟรี" โดยใช้การกำหนดค่า implementation ให้ใช้การกำหนดค่าต่อไปนี้

Kotlin

dependencies {
    freeImplementation("com.google.firebase:firebase-ads:21.5.1")
}

Groovy

dependencies {
    freeImplementation 'com.google.firebase:firebase-ads:21.5.1'
}

อย่างไรก็ตาม หากต้องการเพิ่มการขึ้นต่อกันสำหรับตัวแปรที่รวม Product Flavor และประเภทบิลด์ คุณต้องเริ่มต้นชื่อการกำหนดค่าดังนี้

Kotlin

// Initializes a placeholder for the freeDebugImplementation dependency configuration.
val freeDebugImplementation by configurations.creating

dependencies {
    freeDebugImplementation(project(":free-support"))
}

Groovy

configurations {
    // Initializes a placeholder for the freeDebugImplementation dependency configuration.
    freeDebugImplementation {}
}

dependencies {
    freeDebugImplementation project(":free-support")
}

หากต้องการเพิ่มการอ้างอิง implementation สำหรับการทดสอบในเครื่องและการทดสอบที่มีการวัด ให้ทำดังนี้

Kotlin

dependencies {
    // Adds a remote binary dependency only for local tests.
    testImplementation("junit:junit:4.12")

    // Adds a remote binary dependency only for the instrumented test APK.
    androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1")
}

Groovy

dependencies {
    // Adds a remote binary dependency only for local tests.
    testImplementation 'junit:junit:4.12'

    // Adds a remote binary dependency only for the instrumented test APK.
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
}

อย่างไรก็ตาม การกำหนดค่าบางอย่างอาจไม่สมเหตุสมผลในสถานการณ์นี้ เช่น เนื่องจากโมดูลอื่นๆ ไม่สามารถขึ้นอยู่กับ androidTest คุณจึงได้รับคำเตือนต่อไปนี้หากใช้การกำหนดค่า androidTestApi

WARNING: Configuration 'androidTestApi' is obsolete and has been replaced with
'androidTestImplementation'.

ลำดับการขึ้นต่อกัน

ลำดับที่คุณแสดงรายการทรัพยากร Dependency จะบ่งบอกถึงลำดับความสำคัญของแต่ละรายการ โดยไลบรารีแรกจะมีลำดับความสำคัญสูงกว่าไลบรารีที่สอง ไลบรารีที่สองจะมีลำดับความสำคัญสูงกว่า ไลบรารีที่สาม และต่อไปเรื่อยๆ ลำดับนี้มีความสำคัญในกรณีที่ ผสานรวมทรัพยากรหรือ ผสานรวมองค์ประกอบ Manifest เข้ากับแอปจากไลบรารี

เช่น หากโปรเจ็กต์ประกาศสิ่งต่อไปนี้

การขึ้นต่อกันของ LIB_A และ LIB_B (ตามลำดับ)
และ LIB_A ขึ้นอยู่กับ LIB_C และ LIB_D (ตามลำดับ)
และ LIB_B ยังขึ้นอยู่กับ LIB_C ด้วย

จากนั้นลำดับการอ้างอิงแบบคงที่จะเป็นดังนี้

LIB_A
LIB_D
LIB_B
LIB_C

ซึ่งจะช่วยให้ทั้ง LIB_A และ LIB_B ลบล้าง LIB_C ได้ และ LIB_D ยังคงมีลำดับความสำคัญสูงกว่า LIB_B เนื่องจาก LIB_A (ซึ่งขึ้นอยู่กับ LIB_D) มีลำดับความสำคัญสูงกว่า LIB_B

ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีผสานไฟล์ Manifest จากแหล่งที่มา/การอ้างอิงของโปรเจ็กต์ต่างๆ ได้ที่ ผสานไฟล์ Manifest หลายไฟล์

ข้อมูลการขึ้นต่อกันสำหรับ Play Console

เมื่อสร้างแอป AGP จะรวมข้อมูลเมตาที่อธิบายทรัพยากร Dependency ของไลบรารี ที่คอมไพล์ลงในแอปของคุณ เมื่ออัปโหลดแอป Play Console จะตรวจสอบข้อมูลเมตานี้เพื่อแสดงการแจ้งเตือนปัญหาที่ทราบเกี่ยวกับ SDK และ ทรัพยากร Dependency ที่แอปใช้ และในบางกรณีจะให้ความคิดเห็นที่นำไปใช้ได้จริงเพื่อ แก้ไขปัญหาเหล่านั้น

ระบบจะบีบอัดข้อมูล เข้ารหัสด้วยคีย์การลงนามของ Google Play และจัดเก็บไว้ใน บล็อกการลงนามของแอปเวอร์ชันที่เผยแพร่ เราขอแนะนำให้เก็บไฟล์การอ้างอิงนี้ไว้ เพื่อประสบการณ์การใช้งานที่ปลอดภัยและดีของผู้ใช้ คุณเลือกไม่ใช้ได้โดยใส่บล็อก ต่อไปนี้ dependenciesInfo ในไฟล์ build.gradle.kts ของโมดูล

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

ดูข้อมูลเพิ่มเติมเกี่ยวกับนโยบายและปัญหาที่อาจเกิดขึ้นกับทรัพยากร Dependency ได้ที่หน้าการสนับสนุนเกี่ยวกับการใช้ SDK ของบุคคลที่สามในแอป

ข้อมูลเชิงลึกเกี่ยวกับ SDK

Android Studio จะแสดงคำเตือนของ Lint ในไฟล์แคตตาล็อกเวอร์ชันและกล่องโต้ตอบโครงสร้างโปรเจ็กต์สำหรับ SDK สาธารณะในดัชนี SDK ของ Google Play เมื่อมีปัญหาต่อไปนี้

ผู้เขียน SDK จะทำเครื่องหมายว่า SDK ล้าสมัย
SDK ละเมิดนโยบายของ Play
SDK มีช่องโหว่ด้านความปลอดภัยที่ทราบ
ผู้เขียนได้เลิกใช้งาน SDK เหล่านี้แล้ว

คำเตือนเป็นสัญญาณที่บ่งบอกว่าคุณควรจะอัปเดตการอ้างอิงเหล่านั้น เนื่องจาก การใช้เวอร์ชันที่ล้าสมัยอาจทำให้คุณเผยแพร่ไปยัง Google Play Console ในอนาคตไม่ได้

เพิ่มการพึ่งพาบิลด์โดยไม่มีแคตตาล็อกเวอร์ชัน

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

Kotlin

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

android { ... }

dependencies {
    // Dependency on a remote binary
    implementation("com.example.android:app-magic:12.3")
    // Dependency on a local library module
    implementation(project(":mylibrary"))
}

Groovy

plugins {
    id 'com.android.application'
}

android { ... }

dependencies {
    // Dependency on a remote binary
    implementation 'com.example.android:app-magic:12.3'
    // Dependency on a local library module
    implementation project(':mylibrary')
}

ไฟล์บิลด์นี้ประกาศการขึ้นต่อกันในไลบรารี "app-magic" เวอร์ชัน 12.3 ภายในกลุ่มเนมสเปซ "com.example.android" การประกาศการขึ้นต่อกันของไบนารีระยะไกล เป็นรูปแบบย่อของรายการต่อไปนี้

Kotlin

implementation(group = "com.example.android", name = "app-magic", version = "12.3")

Groovy

implementation group: 'com.example.android', name: 'app-magic', version: '12.3'

ไฟล์บิลด์ยังประกาศการขึ้นต่อกันในโมดูลไลบรารี Android ชื่อ "mylibrary" ด้วย ซึ่งชื่อนี้ต้องตรงกับชื่อไลบรารีที่กำหนดด้วย include: ในไฟล์ settings.gradle.kts เมื่อคุณสร้างแอป ระบบบิลด์จะ คอมไพล์โมดูลไลบรารีและแพ็กเกจเนื้อหาที่คอมไพล์แล้วใน แอป

ไฟล์บิลด์ยังประกาศทรัพยากร Dependency ในปลั๊กอิน Android Gradle (com.application.android) ด้วย หากมีหลายโมดูลที่ใช้ปลั๊กอินเดียวกัน คุณจะมีปลั๊กอินได้เพียงเวอร์ชันเดียวในเส้นทางการจัดประเภทบิลด์ ในทุกโมดูล แทนที่จะระบุเวอร์ชันในสคริปต์บิลด์ของแต่ละโมดูล คุณควรรวมการอ้างอิงปลั๊กอินไว้ในสคริปต์บิลด์รูท พร้อมกับเวอร์ชัน และระบุว่าไม่ต้องใช้ การเพิ่ม apply false จะบอก Gradle ให้บันทึกเวอร์ชันของปลั๊กอิน แต่ไม่ให้ใช้ในบิลด์รูท โดยปกติแล้วสคริปต์การสร้างรูทจะว่างเปล่ายกเว้นบล็อก plugins นี้

Kotlin

plugins {
    id("org.jetbrains.kotlin.android") version "1.9.0" apply false
}

Groovy

plugins {
    id ‘com.android.application’ version ‘8.3.0-rc02’ apply false
}

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

Kotlin

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

Groovy

plugins {
    id 'com.android.application' version '8.3.0-rc02'
}