กำหนดค่าตัวแปรของบิวด์

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

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

ตัวแปรบิลด์เป็นผลลัพธ์ที่ได้จาก Gradle ซึ่งใช้ชุดกฎที่เฉพาะเจาะจง เพื่อรวมการตั้งค่า โค้ด และทรัพยากรที่กำหนดค่าไว้ใน ประเภทบิลด์และ Product Flavor แม้ว่าคุณจะไม่ได้กำหนดค่าตัวแปรบิลด์โดยตรง แต่คุณก็กำหนดค่าประเภทบิลด์และเวอร์ชันผลิตภัณฑ์ที่ประกอบกันเป็นตัวแปรบิลด์

ตัวอย่างเช่น เวอร์ชันผลิตภัณฑ์ "เดโม" อาจระบุฟีเจอร์บางอย่าง และข้อกำหนดของอุปกรณ์ เช่น ซอร์สโค้ด ทรัพยากร และระดับ API ขั้นต่ำ ที่กำหนดเอง ในขณะที่ประเภทบิลด์ "debug" จะใช้การตั้งค่าบิลด์และ การสร้างแพ็กเกจที่แตกต่างกัน เช่น ตัวเลือกการแก้ไขข้อบกพร่องและคีย์การลงนาม ตัวแปรบิลด์ที่รวมทั้ง 2 อย่างนี้คือแอปเวอร์ชัน "demoDebug" ซึ่งรวม การกำหนดค่าและทรัพยากรที่รวมอยู่ในเวอร์ชันผลิตภัณฑ์ "demo" ประเภทบิลด์ "debug" และชุดซอร์ส main/

กำหนดค่าประเภทบิลด์

คุณสร้างและกำหนดค่าประเภทบิลด์ได้ภายในบล็อก android ของไฟล์ build.gradle.kts ระดับโมดูล เมื่อคุณสร้างโมดูลใหม่ Android Studio จะสร้างประเภทบิลด์ดีบักและบิลด์ที่เผยแพร่โดยอัตโนมัติ แม้ว่าบิลด์การแก้ไขข้อบกพร่องจะไม่ปรากฏในไฟล์การกำหนดค่าบิลด์ แต่ Android Studio จะกำหนดค่าด้วย debuggable true ซึ่งจะช่วยให้คุณแก้ไขข้อบกพร่องของแอปในอุปกรณ์ Android ที่ปลอดภัยและ กำหนดค่า App Signing ด้วยที่เก็บคีย์การแก้ไขข้อบกพร่องทั่วไป

คุณเพิ่มประเภทบิลด์การแก้ไขข้อบกพร่องลงในการกำหนดค่าได้หากต้องการเพิ่ม หรือเปลี่ยนการตั้งค่าบางอย่าง ตัวอย่างต่อไปนี้ระบุ applicationIdSuffix สำหรับประเภทบิลด์การแก้ไขข้อบกพร่อง และกำหนดค่า ประเภทบิลด์ "staging" ที่เริ่มต้นโดยใช้การตั้งค่าจากประเภทบิลด์การแก้ไขข้อบกพร่อง

Kotlin

android {
    defaultConfig {
        manifestPlaceholders["hostName"] = "www.example.com"
        ...
    }
    buildTypes {
        getByName("release") {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
        }

        getByName("debug") {
            applicationIdSuffix = ".debug"
            isDebuggable = true
        }

        /**
         * The `initWith` property lets you copy configurations from other build types,
         * then configure only the settings you want to change. This one copies the debug build
         * type, and then changes the manifest placeholder and application ID.
         */
        create("staging") {
            initWith(getByName("debug"))
            manifestPlaceholders["hostName"] = "internal.example.com"
            applicationIdSuffix = ".debugStaging"
        }
    }
}

ดึงดูด

android {
    defaultConfig {
        manifestPlaceholders = [hostName:"www.example.com"]
        ...
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }

        debug {
            applicationIdSuffix ".debug"
            debuggable true
        }

        /**
         * The `initWith` property lets you copy configurations from other build types,
         * then configure only the settings you want to change. This one copies the debug build
         * type, and then changes the manifest placeholder and application ID.
         */
        staging {
            initWith debug
            manifestPlaceholders = [hostName:"internal.example.com"]
            applicationIdSuffix ".debugStaging"
        }
    }
}

หมายเหตุ: เมื่อทำการเปลี่ยนแปลงไฟล์การกำหนดค่าบิลด์ Android Studio จะกำหนดให้คุณซิงค์โปรเจ็กต์กับการกำหนดค่าใหม่ หากต้องการซิงค์โปรเจ็กต์ ให้คลิกซิงค์เลย ในแถบการแจ้งเตือนที่ปรากฏขึ้นเมื่อคุณทำการเปลี่ยนแปลง หรือคลิก ซิงค์โปรเจ็กต์ จากแถบเครื่องมือ หาก Android Studio พบข้อผิดพลาดในการกำหนดค่า หน้าต่างข้อความจะปรากฏขึ้นเพื่ออธิบายปัญหา

ดูข้อมูลเพิ่มเติมเกี่ยวกับพร็อพเพอร์ตี้ทั้งหมดที่คุณกําหนดค่าได้ด้วยประเภทบิลด์ โปรดอ่านข้อมูลอ้างอิงของ BuildType

กำหนดค่ารสชาติของผลิตภัณฑ์

การสร้างรสชาติของผลิตภัณฑ์คล้ายกับการสร้างประเภทบิลด์ เพิ่มรสชาติของผลิตภัณฑ์ลงในบล็อก productFlavors ในการกำหนดค่าบิลด์และรวมการตั้งค่าที่ต้องการ เวอร์ชันผลิตภัณฑ์ รองรับพร็อพเพอร์ตี้เดียวกันกับ defaultConfig เนื่องจาก defaultConfig เป็นของคลาส ProductFlavor จริงๆ ซึ่งหมายความว่าคุณสามารถระบุการกำหนดค่าพื้นฐานสำหรับทุกรสชาติในบล็อก defaultConfig และแต่ละรสชาติสามารถเปลี่ยนค่าเริ่มต้นเหล่านี้ได้ เช่น applicationId หากต้องการ ดูข้อมูลเพิ่มเติมเกี่ยวกับรหัสแอปพลิเคชัน โปรดอ่าน ตั้งค่ารหัสแอปพลิเคชัน

หมายเหตุ: คุณยังคงต้องระบุชื่อแพ็กเกจโดยใช้แอตทริบิวต์ package ในไฟล์ Manifest main/ นอกจากนี้ คุณต้องใช้ชื่อแพ็กเกจดังกล่าวในซอร์สโค้ดเพื่ออ้างอิงถึงคลาส R หรือเพื่อแก้ไขการลงทะเบียนกิจกรรมหรือบริการที่เกี่ยวข้อง ซึ่งจะช่วยให้คุณใช้ applicationId เพื่อให้เวอร์ชันผลิตภัณฑ์แต่ละรายการมีรหัสที่ไม่ซ้ำกันสำหรับ การสร้างแพ็กเกจและการจัดจำหน่ายโดยไม่ต้องเปลี่ยนซอร์สโค้ด

รสชาติทั้งหมดต้องอยู่ในมิติข้อมูลรสชาติที่มีชื่อ ซึ่งเป็นกลุ่มของรสชาติผลิตภัณฑ์ คุณต้องกำหนดรสชาติทั้งหมดให้กับมิติข้อมูลรสชาติ มิฉะนั้นคุณจะได้รับข้อผิดพลาดในการสร้างต่อไปนี้ 

  Error: All flavors must now belong to a named flavor dimension.
  The flavor 'flavor_name' is not assigned to a flavor dimension.

หากโมดูลที่ระบุมีมิติข้อมูลของเวอร์ชันเพียงรายการเดียว ปลั๊กอิน Android Gradle จะกำหนดเวอร์ชันทั้งหมดของโมดูลให้กับมิติข้อมูลนั้นโดยอัตโนมัติ

ตัวอย่างโค้ดต่อไปนี้สร้างมิติข้อมูลรสชาติชื่อ "version" และเพิ่มรสชาติผลิตภัณฑ์ "demo" และ "full" โดยแต่ละรสชาติจะมี applicationIdSuffix และ versionNameSuffix ของตัวเอง

Kotlin

android {
    ...
    defaultConfig {...}
    buildTypes {
        getByName("debug"){...}
        getByName("release"){...}
    }
    // Specifies one flavor dimension.
    flavorDimensions += "version"
    productFlavors {
        create("demo") {
            // Assigns this product flavor to the "version" flavor dimension.
            // If you are using only one dimension, this property is optional,
            // and the plugin automatically assigns all the module's flavors to
            // that dimension.
            dimension = "version"
            applicationIdSuffix = ".demo"
            versionNameSuffix = "-demo"
        }
        create("full") {
            dimension = "version"
            applicationIdSuffix = ".full"
            versionNameSuffix = "-full"
        }
    }
}

ดึงดูด

android {
    ...
    defaultConfig {...}
    buildTypes {
        debug{...}
        release{...}
    }
    // Specifies one flavor dimension.
    flavorDimensions "version"
    productFlavors {
        demo {
            // Assigns this product flavor to the "version" flavor dimension.
            // If you are using only one dimension, this property is optional,
            // and the plugin automatically assigns all the module's flavors to
            // that dimension.
            dimension "version"
            applicationIdSuffix ".demo"
            versionNameSuffix "-demo"
        }
        full {
            dimension "version"
            applicationIdSuffix ".full"
            versionNameSuffix "-full"
        }
    }
}

หมายเหตุ: หากคุณมีแอปเวอร์ชันเดิม (สร้างก่อนเดือนสิงหาคม 2021) ที่จัดจำหน่ายโดยใช้ APK ใน Google Play หากต้องการจัดจำหน่ายแอปโดยใช้การรองรับ APK หลายรายการใน Google Play ให้กำหนดapplicationIdค่าเดียวกัน ให้กับตัวแปรทั้งหมด และกำหนดversionCode ที่แตกต่างกันให้กับตัวแปรแต่ละรายการ หากต้องการเผยแพร่แอปเวอร์ชันต่างๆ เป็นแอปแยกกันใน Google Play คุณต้องกำหนด applicationId ที่แตกต่างกันให้กับแต่ละเวอร์ชัน

หลังจากสร้างและกำหนดค่ารสชาติของผลิตภัณฑ์แล้ว ให้คลิกซิงค์ เลยในแถบการแจ้งเตือน เมื่อการซิงค์เสร็จสมบูรณ์แล้ว Gradle จะสร้างตัวแปรบิลด์โดยอัตโนมัติตามประเภทบิลด์และรสชาติผลิตภัณฑ์ และตั้งชื่อตาม<product-flavor><Build-Type> ตัวอย่างเช่น หากคุณ สร้างรสชาติผลิตภัณฑ์ "demo" และ "full" และเก็บค่าเริ่มต้น "debug" และ ประเภทบิลด์ "release" ไว้ Gradle จะสร้างตัวแปรบิลด์ต่อไปนี้

  • demoDebug
  • demoRelease
  • fullDebug
  • fullRelease

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

เปลี่ยนรหัสแอปพลิเคชันสำหรับตัวแปรบิลด์

เมื่อคุณสร้าง APK หรือ AAB สำหรับแอป เครื่องมือบิลด์จะติดแท็กแอปด้วย รหัสแอปพลิเคชันที่กำหนดไว้ในบล็อก defaultConfig จากไฟล์ build.gradle.kts ดังที่แสดงในตัวอย่างต่อไปนี้ อย่างไรก็ตาม หากต้องการสร้างแอปเวอร์ชันต่างๆ ให้ปรากฏเป็นข้อมูลแยกกันใน Google Play Store เช่น เวอร์ชัน "ฟรี" และ "โปร" คุณจะต้องสร้างตัวแปรบิลด์แยกกันซึ่งแต่ละตัวแปรจะมีรหัสแอปพลิเคชันที่แตกต่างกัน

ในกรณีนี้ ให้กำหนดแต่ละตัวแปรบิลด์เป็นเวอร์ชันผลิตภัณฑ์แยกกัน สำหรับแต่ละรสชาติ ภายในบล็อก productFlavors คุณสามารถกำหนดพร็อพเพอร์ตี้ applicationId ใหม่ หรือจะต่อท้ายกลุ่มกับรหัสแอปพลิเคชันเริ่มต้น โดยใช้ applicationIdSuffix แทนก็ได้ ดังที่แสดงที่นี่

Kotlin

android {
    defaultConfig {
        applicationId = "com.example.myapp"
    }
    productFlavors {
        create("free") {
            applicationIdSuffix = ".free"
        }
        create("pro") {
            applicationIdSuffix = ".pro"
        }
    }
}

ดึงดูด

android {
    defaultConfig {
        applicationId "com.example.myapp"
    }
    productFlavors {
        free {
            applicationIdSuffix ".free"
        }
        pro {
            applicationIdSuffix ".pro"
        }
    }
}

ด้วยวิธีนี้ รหัสแอปพลิเคชันสำหรับเวอร์ชันผลิตภัณฑ์ "ฟรี" จะเป็น "com.example.myapp.free"

นอกจากนี้ คุณยังใช้ applicationIdSuffix เพื่อต่อท้ายกลุ่มตามประเภทบิลด์ได้ด้วย ดังที่แสดงที่นี่

Kotlin

android {
    ...
    buildTypes {
        getByName("debug") {
            applicationIdSuffix = ".debug"
        }
    }
}

ดึงดูด

android {
    ...
    buildTypes {
        debug {
            applicationIdSuffix ".debug"
        }
    }
}

เนื่องจาก Gradle ใช้การกำหนดค่าประเภทบิลด์หลังจากเวอร์ชันผลิตภัณฑ์ รหัสแอปพลิเคชันสำหรับตัวแปรบิลด์ "free debug" คือ "com.example.myapp.free.debug" ซึ่งจะมีประโยชน์เมื่อคุณต้องการมีทั้ง บิลด์การแก้ไขข้อบกพร่องและบิลด์ที่เผยแพร่ในอุปกรณ์เดียวกัน เนื่องจากแอป 2 แอปไม่สามารถมี รหัสแอปพลิเคชันเดียวกันได้

หากมีแอปเวอร์ชันเดิม (สร้างขึ้นก่อนเดือนสิงหาคม 2021) ที่คุณเผยแพร่โดยใช้ APK ใน Google Play และต้องการใช้ข้อมูลแอปเดียวกันเพื่อเผยแพร่ APK หลายรายการที่แต่ละรายการกำหนดเป้าหมายเป็นการกำหนดค่าอุปกรณ์ที่แตกต่างกัน เช่น ระดับ API คุณต้องใช้รหัสแอปพลิเคชันเดียวกันสำหรับตัวแปรบิลด์แต่ละรายการ แต่ต้องกำหนด versionCode ที่แตกต่างกันให้กับ APK แต่ละรายการ ดูข้อมูลเพิ่มเติมได้ที่หัวข้อการรองรับ APK หลายรายการ การเผยแพร่โดยใช้ AAB จะไม่ได้รับผลกระทบ เนื่องจากใช้ Artifact เดียวที่ใช้รหัสเวอร์ชันและรหัสแอปพลิเคชันเดียวโดยค่าเริ่มต้น

เคล็ดลับ: หากต้องการอ้างอิงรหัสแอปพลิเคชันในไฟล์ ไฟล์ Manifest คุณสามารถใช้ตัวยึดตำแหน่ง ${applicationId} ในแอตทริบิวต์ Manifest ใดก็ได้ ในระหว่างการสร้าง Gradle จะแทนที่แท็กนี้ด้วยรหัสแอปพลิเคชันจริง ดูข้อมูลเพิ่มเติมได้ที่แทรกตัวแปรบิลด์ ลงในไฟล์ Manifest

รวมผลิตภัณฑ์หลายเวอร์ชันเข้ากับมิติข้อมูลเวอร์ชัน

ในบางกรณี คุณอาจต้องการรวมการกำหนดค่าจากผลิตภัณฑ์หลาย รูปแบบ เช่น คุณอาจต้องการสร้างการกำหนดค่าที่แตกต่างกันสำหรับ "full" และ "demo" ที่อิงตามระดับ API หากต้องการทำเช่นนี้ ปลั๊กอิน Android Gradle จะช่วยให้คุณสร้างกลุ่มหลายกลุ่มของ Product Flavor เป็นมิติข้อมูล Flavor ได้

เมื่อสร้างแอป Gradle จะรวมการกำหนดค่าเวอร์ชันผลิตภัณฑ์จากมิติข้อมูลของเวอร์ชันแต่ละรายการที่คุณกำหนดไว้กับการกำหนดค่าประเภทบิลด์เพื่อสร้างตัวแปรบิลด์สุดท้าย Gradle จะไม่รวมเวอร์ชันผลิตภัณฑ์ที่อยู่ในมิติข้อมูลของเวอร์ชันเดียวกัน

ตัวอย่างโค้ดต่อไปนี้ใช้พร็อพเพอร์ตี้ flavorDimensions เพื่อสร้างมิติข้อมูลของเวอร์ชัน "โหมด" เพื่อจัดกลุ่มเวอร์ชันผลิตภัณฑ์ "เต็ม" และ "เดโม" และมิติข้อมูลของเวอร์ชัน "api" เพื่อจัดกลุ่มการกำหนดค่าเวอร์ชันผลิตภัณฑ์ตามระดับ API

Kotlin

android {
  ...
  buildTypes {
    getByName("debug") {...}
    getByName("release") {...}
  }

  // Specifies the flavor dimensions you want to use. The order in which you
  // list the dimensions determines their priority, from highest to lowest,
  // when Gradle merges variant sources and configurations. You must assign
  // each product flavor you configure to one of the flavor dimensions.
  flavorDimensions += listOf("api", "mode")

  productFlavors {
    create("demo") {
      // Assigns this product flavor to the "mode" flavor dimension.
      dimension = "mode"
      ...
    }

    create("full") {
      dimension = "mode"
      ...
    }

    // Configurations in the "api" product flavors override those in "mode"
    // flavors and the defaultConfig block. Gradle determines the priority
    // between flavor dimensions based on the order in which they appear next
    // to the flavorDimensions property, with the first dimension having a higher
    // priority than the second, and so on.
    create("minApi24") {
      dimension = "api"
      minSdk = 24
      // To ensure the target device receives the version of the app with
      // the highest compatible API level, assign version codes in increasing
      // value with API level.
      versionCode = 30000 + (android.defaultConfig.versionCode ?: 0)
      versionNameSuffix = "-minApi24"
      ...
    }

    create("minApi23") {
      dimension = "api"
      minSdk = 23
      versionCode = 20000  + (android.defaultConfig.versionCode ?: 0)
      versionNameSuffix = "-minApi23"
      ...
    }

    create("minApi21") {
      dimension = "api"
      minSdk = 21
      versionCode = 10000  + (android.defaultConfig.versionCode ?: 0)
      versionNameSuffix = "-minApi21"
      ...
    }
  }
}
...

ดึงดูด

android {
  ...
  buildTypes {
    debug {...}
    release {...}
  }

  // Specifies the flavor dimensions you want to use. The order in which you
  // list the dimensions determines their priority, from highest to lowest,
  // when Gradle merges variant sources and configurations. You must assign
  // each product flavor you configure to one of the flavor dimensions.
  flavorDimensions "api", "mode"

  productFlavors {
    demo {
      // Assigns this product flavor to the "mode" flavor dimension.
      dimension "mode"
      ...
    }

    full {
      dimension "mode"
      ...
    }

    // Configurations in the "api" product flavors override those in "mode"
    // flavors and the defaultConfig block. Gradle determines the priority
    // between flavor dimensions based on the order in which they appear next
    // to the flavorDimensions property, with the first dimension having a higher
    // priority than the second, and so on.
    minApi24 {
      dimension "api"
      minSdkVersion 24
      // To ensure the target device receives the version of the app with
      // the highest compatible API level, assign version codes in increasing
      // value with API level.

      versionCode 30000 + android.defaultConfig.versionCode
      versionNameSuffix "-minApi24"
      ...
    }

    minApi23 {
      dimension "api"
      minSdkVersion 23
      versionCode 20000  + android.defaultConfig.versionCode
      versionNameSuffix "-minApi23"
      ...
    }

    minApi21 {
      dimension "api"
      minSdkVersion 21
      versionCode 10000  + android.defaultConfig.versionCode
      versionNameSuffix "-minApi21"
      ...
    }
  }
}
...

จำนวนตัวแปรบิลด์ที่ Gradle สร้างจะเท่ากับผลคูณของจำนวนรสชาติในมิติรสชาติแต่ละมิติและจำนวนประเภทบิลด์ที่คุณกำหนดค่า เมื่อ Gradle ตั้งชื่อตัวแปรบิลด์แต่ละรายการหรืออาร์ติแฟกต์ที่เกี่ยวข้อง เวอร์ชันผลิตภัณฑ์ที่อยู่ในมิติข้อมูลของเวอร์ชันที่มีลำดับความสำคัญสูงกว่าจะปรากฏก่อน ตามด้วยเวอร์ชันผลิตภัณฑ์จากมิติข้อมูลของเวอร์ชันที่มีลำดับความสำคัญต่ำกว่า และตามด้วยประเภทบิลด์

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

  • ตัวแปรบิลด์: [minApi24, minApi23, minApi21][Demo, Full][Debug, Release]
  • APK ที่เกี่ยวข้อง: app-[minApi24, minApi23, minApi21]-[demo, full]-[debug, release].apk
    • ตัวอย่างเช่น
    ตัวแปรบิลด์: minApi24DemoDebug
    APK ที่เกี่ยวข้อง: app-minApi24-demo-debug.apk

นอกเหนือจากไดเรกทอรีชุดซอร์สที่คุณสร้างสำหรับแต่ละ เวอร์ชันผลิตภัณฑ์และตัวแปรบิลด์แล้ว คุณยังสร้างไดเรกทอรีชุดซอร์ส สำหรับชุดค่าผสมแต่ละชุดของเวอร์ชันผลิตภัณฑ์ได้ด้วย เช่น คุณสร้าง และเพิ่มแหล่งที่มาของ Java ไปยังไดเรกทอรี src/demoMinApi24/java/ ได้ และ Gradle จะใช้แหล่งที่มาเหล่านั้นเฉพาะเมื่อสร้างตัวแปรที่รวม รสชาติของผลิตภัณฑ์ทั้ง 2 รายการนั้น

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

กรองตัวแปร

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

ใช้การกำหนดค่าบิลด์จากส่วนก่อนหน้าเป็นตัวอย่าง สมมติว่าคุณวางแผนที่จะรองรับเฉพาะ API ระดับ 23 ขึ้นไปสำหรับเวอร์ชัน สาธิตของแอป คุณสามารถใช้บล็อก variantFilter เพื่อกรองการกำหนดค่าตัวแปรบิลด์ทั้งหมด ที่รวมรสชาติผลิตภัณฑ์ "minApi21" และ "demo" ได้ดังนี้

Kotlin

android {
  ...
  buildTypes {...}

  flavorDimensions += listOf("api", "mode")
  productFlavors {
    create("demo") {...}
    create("full") {...}
    create("minApi24") {...}
    create("minApi23") {...}
    create("minApi21") {...}
  }
}

androidComponents {
    beforeVariants { variantBuilder ->
        // To check for a certain build type, use variantBuilder.buildType == "<buildType>"
        if (variantBuilder.productFlavors.containsAll(listOf("api" to "minApi21", "mode" to "demo"))) {
            // Gradle ignores any variants that satisfy the conditions above.
            variantBuilder.enable = false
        }
    }
}
...

ดึงดูด

android {
  ...
  buildTypes {...}

  flavorDimensions "api", "mode"
  productFlavors {
    demo {...}
    full {...}
    minApi24 {...}
    minApi23 {...}
    minApi21 {...}
  }

  variantFilter { variant ->
      def names = variant.flavors*.name
      // To check for a certain build type, use variant.buildType.name == "<buildType>"
      if (names.contains("minApi21") && names.contains("demo")) {
          // Gradle ignores any variants that satisfy the conditions above.
          setIgnore(true)
      }
  }
}
...

เมื่อเพิ่มตัวกรองตัวแปรไปยังการกำหนดค่าบิลด์แล้วคลิกซิงค์ ตอนนี้ในแถบการแจ้งเตือน Gradle จะไม่สนใจตัวแปรบิลด์ใดๆ ที่ตรงกับ เงื่อนไขที่คุณระบุ ตัวแปรบิลด์จะไม่ปรากฏในเมนูอีกต่อไป เมื่อคุณคลิกบิลด์ > เลือกตัวแปรบิลด์จากแถบเมนู หรือตัวแปรบิลด์ ใน แถบหน้าต่างเครื่องมือ

สร้างชุดแหล่งที่มา

โดยค่าเริ่มต้น Android Studio จะสร้างmain/ ชุดซอร์สและไดเรกทอรีสำหรับ ทุกอย่างที่คุณต้องการแชร์ระหว่างตัวแปรบิลด์ทั้งหมด อย่างไรก็ตาม คุณ สามารถสร้างชุดแหล่งที่มาใหม่เพื่อควบคุมว่า Gradle จะคอมไพล์และ แพ็กเกจไฟล์ใดสำหรับประเภทบิลด์, Product Flavor, ชุดค่าผสมของ Product Flavor (เมื่อใช้มิติข้อมูล Flavor) และตัวแปรบิลด์ที่เฉพาะเจาะจง

เช่น คุณสามารถกำหนดฟังก์ชันพื้นฐานในmain/ชุดซอร์สและใช้เวอร์ชันผลิตภัณฑ์เพื่อเปลี่ยนการสร้างแบรนด์ของแอปสำหรับไคลเอ็นต์ต่างๆ หรือรวมสิทธิ์พิเศษและฟังก์ชันการบันทึกเฉพาะสำหรับตัวแปรบิลด์ที่ใช้บิลด์การแก้ไขข้อบกพร่อง

Gradle คาดหวังให้จัดระเบียบไฟล์และไดเรกทอรีของชุดซอร์สในลักษณะหนึ่ง ซึ่งคล้ายกับชุดซอร์สของ main/ ตัวอย่างเช่น Gradle คาดหวังให้ไฟล์คลาส Kotlin หรือ Java ที่เฉพาะเจาะจงกับประเภทบิลด์ "debug" อยู่ใน ไดเรกทอรี src/debug/kotlin/ หรือ src/debug/java/

ปลั๊กอิน Android Gradle มีงาน Gradle ที่มีประโยชน์ซึ่งจะแสดงวิธีจัดระเบียบไฟล์สำหรับประเภทบิลด์ รสชาติของผลิตภัณฑ์ และตัวแปรบิลด์แต่ละรายการ ตัวอย่างเช่น ตัวอย่างต่อไปนี้จากเอาต์พุตของงาน อธิบายตำแหน่งที่ Gradle คาดว่าจะพบไฟล์บางอย่างสำหรับบิลด์ประเภท "debug" 

------------------------------------------------------------
Project :app
------------------------------------------------------------

...

debug
----
Compile configuration: debugCompile
build.gradle name: android.sourceSets.debug
Java sources: [app/src/debug/java]
Kotlin sources: [app/src/debug/kotlin, app/src/debug/java]
Manifest file: app/src/debug/AndroidManifest.xml
Android resources: [app/src/debug/res]
Assets: [app/src/debug/assets]
AIDL sources: [app/src/debug/aidl]
RenderScript sources: [app/src/debug/rs]
JNI sources: [app/src/debug/jni]
JNI libraries: [app/src/debug/jniLibs]
Java-style resources: [app/src/debug/resources]

หากต้องการดูเอาต์พุตนี้ ให้ทำตามขั้นตอนต่อไปนี้

  1. คลิก Gradle ในแถบหน้าต่างเครื่องมือ

  2. ไปที่ MyApplication > Tasks > android แล้ว ดับเบิลคลิก sourceSets

    หากต้องการดูโฟลเดอร์ Tasks คุณต้องอนุญาตให้ Gradle สร้างรายการงาน ในระหว่างการซิงค์ โดยทำตามขั้นตอนต่อไปนี้

    1. คลิกไฟล์ > การตั้งค่า > ทดลอง (Android Studio > การตั้งค่า > ทดลอง ใน macOS)
    2. ยกเลิกการเลือกไม่ต้องสร้างรายการงาน Gradle ระหว่างการซิงค์ Gradle
  3. หลังจาก Gradle ดำเนินการในงานแล้ว หน้าต่างเรียกใช้จะเปิดขึ้นเพื่อแสดงเอาต์พุต

หมายเหตุ: เอาต์พุตของงานยังแสดงวิธีจัดระเบียบชุดซอร์ส สำหรับไฟล์ที่คุณต้องการใช้เพื่อเรียกใช้การทดสอบสำหรับแอป เช่น test/ และ androidTest/ ชุดซอร์สสำหรับการทดสอบ

เมื่อสร้างตัวแปรบิลด์ใหม่ Android Studio จะไม่สร้างไดเรกทอรีชุดแหล่งที่มาให้ แต่จะมีตัวเลือก 2-3 อย่างที่จะช่วยคุณ เช่น หากต้องการสร้างเฉพาะไดเรกทอรี java/ สำหรับประเภทบิลด์ "debug" ให้ทำดังนี้

  1. เปิดแผงโปรเจ็กต์ แล้วเลือกมุมมองโปรเจ็กต์จากเมนูที่ด้านบนของแผง
  2. ไปยัง MyProject/app/src/
  3. คลิกขวาที่ไดเรกทอรี src แล้วเลือก New > Directory
  4. จากเมนูในส่วน Gradle Source Sets ให้เลือก full/java
  5. กด Enter

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

เช่น หากต้องการสร้างไฟล์ XML ของค่าสำหรับประเภทบิลด์ "debug" ให้ทำดังนี้

  1. ในแผงโปรเจ็กต์ ให้คลิกขวาที่ไดเรกทอรี src แล้วเลือกใหม่ > XML > ไฟล์ XML ของค่า
  2. ป้อนชื่อไฟล์ XML หรือใช้ชื่อเริ่มต้น
  3. จากเมนูข้างชุดแหล่งข้อมูลเป้าหมาย ให้เลือก debug
  4. คลิกเสร็จสิ้น

เนื่องจากมีการระบุประเภทบิลด์ "debug" เป็นชุดซอร์สเป้าหมาย Android Studio จึงสร้างไดเรกทอรีที่จำเป็นโดยอัตโนมัติเมื่อสร้างไฟล์ XML โครงสร้างไดเรกทอรีที่ได้จะมีลักษณะดังรูปที่ 1

รูปที่ 1 ไดเรกทอรีชุดซอร์สใหม่สำหรับการสร้างประเภท "debug"

ชุดแหล่งข้อมูลที่ใช้งานอยู่จะมีสัญญาณบอกสถานะสีเขียวในไอคอนเพื่อแสดงว่าชุดดังกล่าวใช้งานอยู่ debug ชุดซอร์สจะต่อท้ายด้วย [main] เพื่อแสดงว่าระบบจะผสานรวม เข้ากับชุดซอร์ส main

คุณยังสร้างไดเรกทอรีชุดซอร์สสำหรับ เวอร์ชันผลิตภัณฑ์ เช่น src/demo/ และตัวแปรบิลด์ เช่น src/demoDebug/ ได้ด้วยขั้นตอนเดียวกัน นอกจากนี้ คุณยังสร้างชุดแหล่งที่มาสำหรับการทดสอบ ที่กำหนดเป้าหมายไปยังตัวแปรบิลด์ที่เฉพาะเจาะจงได้ด้วย เช่น src/androidTestDemoDebug/ ดูข้อมูลเพิ่มเติมได้ที่หัวข้อเกี่ยวกับ การทดสอบชุดแหล่งที่มา

เปลี่ยนการกำหนดค่าชุดซอร์สเริ่มต้น

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

บล็อก sourceSets ต้องอยู่ในบล็อก android คุณไม่จำเป็นต้องย้ายไฟล์ต้นฉบับ เพียงแค่ระบุเส้นทางที่สัมพันธ์กับไฟล์ build.gradle.kts ระดับโมดูลให้ Gradle เพื่อให้ Gradle ค้นหาไฟล์สำหรับคอมโพเนนต์แต่ละชุดซอร์สได้ ดูว่าคุณกำหนดค่าคอมโพเนนต์ใดได้บ้าง และจะแมปคอมโพเนนต์กับไฟล์หรือไดเรกทอรีหลายรายการได้หรือไม่ ได้ที่เอกสารอ้างอิง API ของปลั๊กอิน Android Gradle

ตัวอย่างโค้ดต่อไปนี้จะแมปแหล่งที่มาจากไดเรกทอรี app/other/ ไปยังคอมโพเนนต์บางอย่างของชุดซอร์ส main และเปลี่ยน ไดเรกทอรีรากของชุดซอร์ส androidTest

Kotlin

android {
  ...
  // Encapsulates configurations for the main source set.
  sourceSets.getByName("main") {
    // Changes the directory for Java sources. The default directory is
    // 'src/main/java'.
    java.setSrcDirs(listOf("other/java"))

    // If you list multiple directories, Gradle uses all of them to collect
    // sources. Because Gradle gives these directories equal priority, if
    // you define the same resource in more than one directory, you receive an
    // error when merging resources. The default directory is 'src/main/res'.
    res.setSrcDirs(listOf("other/res1", "other/res2"))

    // Note: Avoid specifying a directory that is a parent to one
    // or more other directories you specify. For example, avoid the following:
    // res.srcDirs = ['other/res1', 'other/res1/layouts', 'other/res1/strings']
    // Specify either only the root 'other/res1' directory or only the
    // nested 'other/res1/layouts' and 'other/res1/strings' directories.

    // For each source set, you can specify only one Android manifest.
    // By default, Android Studio creates a manifest for your main source
    // set in the src/main/ directory.
    manifest.srcFile("other/AndroidManifest.xml")
    ...
  }

  // Create additional blocks to configure other source sets.
  sourceSets.getByName("androidTest") {
      // If all the files for a source set are located under a single root
      // directory, you can specify that directory using the setRoot property.
      // When gathering sources for the source set, Gradle looks only in locations
      // relative to the root directory you specify. For example, after applying the
      // configuration below for the androidTest source set, Gradle looks for Java
      // sources only in the src/tests/java/ directory.
      setRoot("src/tests")
      ...
  }
}
...

ดึงดูด

android {
  ...
  sourceSets {
    // Encapsulates configurations for the main source set.
    main {
      // Changes the directory for Java sources. The default directory is
      // 'src/main/java'.
      java.srcDirs = ['other/java']

      // If you list multiple directories, Gradle uses all of them to collect
      // sources. Because Gradle gives these directories equal priority, if
      // you define the same resource in more than one directory, you receive an
      // error when merging resources. The default directory is 'src/main/res'.
      res.srcDirs = ['other/res1', 'other/res2']

      // Note: Avoid specifying a directory that is a parent to one
      // or more other directories you specify. For example, avoid the following:
      // res.srcDirs = ['other/res1', 'other/res1/layouts', 'other/res1/strings']
      // Specify either only the root 'other/res1' directory or only the
      // nested 'other/res1/layouts' and 'other/res1/strings' directories.

      // For each source set, you can specify only one Android manifest.
      // By default, Android Studio creates a manifest for your main source
      // set in the src/main/ directory.
      manifest.srcFile 'other/AndroidManifest.xml'
      ...
    }

    // Create additional blocks to configure other source sets.
    androidTest {

      // If all the files for a source set are located under a single root
      // directory, you can specify that directory using the setRoot property.
      // When gathering sources for the source set, Gradle looks only in locations
      // relative to the root directory you specify. For example, after applying the
      // configuration below for the androidTest source set, Gradle looks for Java
      // sources only in the src/tests/java/ directory.
      setRoot 'src/tests'
      ...
    }
  }
}
...

โปรดทราบว่าไดเรกทอรีต้นทางจะเป็นของชุดซอร์สได้เพียงชุดเดียว เช่น คุณแชร์แหล่งที่มาของการทดสอบเดียวกันกับทั้งชุดแหล่งที่มา test และ androidTest ไม่ได้ เนื่องจาก Android Studio จะสร้างโมดูล IntelliJ แยกต่างหากสำหรับแต่ละชุดซอร์สและไม่รองรับรูทเนื้อหาที่ซ้ำกันในชุดซอร์ส

สร้างด้วยชุดซอร์ส

คุณสามารถใช้ไดเรกทอรีชุดซอร์สเพื่อเก็บโค้ดและทรัพยากรที่ต้องการ แพ็กเกจเฉพาะกับการกำหนดค่าบางอย่าง ตัวอย่างเช่น หากคุณกำลังสร้างตัวแปรบิลด์ "demoDebug" ซึ่งเป็นผลิตภัณฑ์ข้ามผลิตภัณฑ์ของเวอร์ชันผลิตภัณฑ์ "demo" และประเภทบิลด์ "debug" Gradle จะดูไดเรกทอรีเหล่านี้และกำหนดลำดับความสำคัญต่อไปนี้

  1. src/demoDebug/ (ชุดซอร์สของตัวแปรบิลด์)
  2. src/debug/ (ชุดซอร์สของประเภทบิลด์)
  3. src/demo/ (ชุดซอร์สของเวอร์ชันผลิตภัณฑ์)
  4. src/main/ (ชุดซอร์สหลัก)

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

หากรวมรสชาติของผลิตภัณฑ์หลายรายการ ระบบจะกำหนดลำดับความสำคัญระหว่างรสชาติของผลิตภัณฑ์ตามมิติข้อมูลรสชาติ ที่รสชาติเหล่านั้นสังกัดอยู่ เมื่อแสดงมิติข้อมูลรสชาติด้วยพร็อพเพอร์ตี้ android.flavorDimensions รสชาติของผลิตภัณฑ์ที่อยู่ในมิติข้อมูลรสชาติแรกที่คุณแสดงจะมีลำดับความสำคัญสูงกว่ารสชาติที่อยู่ในมิติข้อมูลรสชาติที่สอง และอื่นๆ นอกจากนี้ ชุดซอร์สที่คุณสร้างขึ้นสำหรับชุดค่าผสมของเวอร์ชันผลิตภัณฑ์จะมีลำดับความสำคัญสูงกว่า ชุดซอร์สที่เป็นของเวอร์ชันผลิตภัณฑ์แต่ละรายการ

ลำดับความสำคัญจะเป็นตัวกำหนดว่าชุดซอร์สใดมีลำดับความสำคัญสูงกว่า เมื่อ Gradle รวมโค้ดและทรัพยากร เนื่องจากไดเรกทอรีชุดซอร์ส demoDebug/ น่าจะมีไฟล์ที่เฉพาะเจาะจงกับตัวแปรบิลด์นั้น หาก demoDebug/ มีไฟล์ที่กำหนดไว้ใน debug/ ด้วย Gradle จะใช้ไฟล์ในชุดซอร์ส demoDebug/ ในทำนองเดียวกัน Gradle จะให้ความสำคัญกับไฟล์ในชุดซอร์สของประเภทบิลด์และเวอร์ชันผลิตภัณฑ์ มากกว่าไฟล์เดียวกันใน main/ Gradle จะพิจารณาลำดับความสำคัญนี้เมื่อใช้กฎการสร้างต่อไปนี้

  • ระบบจะคอมไพล์ซอร์สโค้ดทั้งหมดในไดเรกทอรี kotlin/ หรือ java/ ร่วมกันเพื่อสร้างเอาต์พุตเดียว

    หมายเหตุ: สำหรับตัวแปรบิลด์ที่กำหนด Gradle จะส่งข้อผิดพลาดในการบิลด์ หากพบไดเรกทอรีชุดซอร์สอย่างน้อย 2 รายการที่กำหนด คลาส Kotlin หรือ Java เดียวกัน ตัวอย่างเช่น เมื่อสร้างแอปสำหรับแก้ไขข้อบกพร่อง คุณจะ กำหนดทั้ง src/debug/Utility.kt และ src/main/Utility.kt ไม่ได้ เนื่องจาก Gradle จะดูทั้ง ไดเรกทอรีเหล่านี้ในระหว่างกระบวนการบิลด์และแสดงข้อผิดพลาด "คลาสซ้ำ" หากต้องการใช้ Utility.kt เวอร์ชันอื่นสำหรับ ประเภทบิลด์ต่างๆ ประเภทบิลด์แต่ละประเภทต้องกำหนดเวอร์ชันของ ไฟล์ของตัวเองและไม่รวมไว้ในชุดซอร์สของ main/

  • ระบบจะผสานไฟล์ Manifest เข้าด้วยกันเป็นไฟล์ Manifest เดียว ระบบจะให้ความสำคัญ ตามลำดับเดียวกับรายการในตัวอย่างก่อนหน้า กล่าวคือ การตั้งค่าไฟล์ Manifest สำหรับประเภทบิลด์จะลบล้างการตั้งค่าไฟล์ Manifest สำหรับเวอร์ชันผลิตภัณฑ์ และอื่นๆ ดูข้อมูลเพิ่มเติมได้ที่การผสานไฟล์ Manifest
  • ระบบจะผสานไฟล์ในไดเรกทอรี values/ เข้าด้วยกัน หากไฟล์ 2 ไฟล์มีชื่อเดียวกัน เช่น ไฟล์ strings.xml 2 ไฟล์ ระบบจะให้ลำดับความสำคัญตามลำดับเดียวกับรายการในตัวอย่างก่อนหน้า กล่าวคือ ค่าที่กำหนดไว้ในไฟล์ในชุดซอร์สของประเภทบิลด์ จะลบล้างค่าที่กำหนดไว้ในไฟล์เดียวกันในเวอร์ชันผลิตภัณฑ์ และอื่นๆ
  • ระบบจะแพ็กเกจทรัพยากรในไดเรกทอรี res/ และ asset/ ไว้ด้วยกัน หากมีทรัพยากรที่มีชื่อเดียวกันซึ่งกำหนดไว้ใน ชุดแหล่งที่มาตั้งแต่ 2 ชุดขึ้นไป ระบบจะให้ลำดับความสำคัญตามลำดับเดียวกับรายการ ในตัวอย่างก่อนหน้า
  • Gradle จะให้ลำดับความสำคัญต่ำสุดแก่ทรัพยากรและไฟล์ Manifest ที่รวมอยู่ในทรัพยากร Dependency ของโมดูลไลบรารี เมื่อสร้างแอป

ประกาศทรัพยากร Dependency

หากต้องการกําหนดค่าทรัพยากร Dependency สําหรับตัวแปรบิลด์หรือชุดซอร์สสำหรับการทดสอบที่เฉพาะเจาะจง ให้ใส่คํานําหน้าชื่อตัวแปรบิลด์หรือชุดซอร์สสำหรับการทดสอบก่อนคีย์เวิร์ด Implementation ดังที่แสดงในตัวอย่างต่อไปนี้

Kotlin

dependencies {
    // Adds the local "mylibrary" module as a dependency to the "free" flavor.
    "freeImplementation"(project(":mylibrary"))

    // 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("com.android.support.test.espresso:espresso-core:3.6.1")
}

ดึงดูด

dependencies {
    // Adds the local "mylibrary" module as a dependency to the "free" flavor.
    freeImplementation project(":mylibrary")

    // 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 'com.android.support.test.espresso:espresso-core:3.6.1'
}

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

ใช้การจัดการทรัพยากร Dependency ที่รับรู้ตัวแปร

ปลั๊กอิน Android Gradle 3.0.0 ขึ้นไปมีกลไกทรัพยากร Dependency ใหม่ที่จับคู่ตัวแปรโดยอัตโนมัติ เมื่อใช้ไลบรารี ซึ่งหมายความว่าdebugตัวแปร ของแอปจะใช้debugตัวแปรของไลบรารีโดยอัตโนมัติ และอื่นๆ นอกจากนี้ยังใช้ได้เมื่อใช้ Flavor ด้วย กล่าวคือ ตัวแปร freeDebug ของแอปจะใช้ตัวแปร freeDebug ของไลบรารี

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

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

Error:Failed to resolve: Could not resolve project :mylibrary.
Required by:
    project :app

แก้ไขข้อผิดพลาดในการสร้างที่เกี่ยวข้องกับการจับคู่ตัวแปร

ปลั๊กอินมีองค์ประกอบ DSL ที่ช่วยให้คุณควบคุมวิธีที่ Gradle แก้ไขสถานการณ์ที่แอปและ Dependency ไม่สามารถจับคู่ตัวแปรโดยตรงได้

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

  • แอปของคุณมีประเภทบิลด์ที่ทรัพยากร Dependency ของไลบรารีไม่มี

    เช่น แอปของคุณมีประเภทบิลด์ "staging" แต่ทรัพยากร Dependency มีเฉพาะประเภทบิลด์ "debug" และ "release"

    โปรดทราบว่าไม่มีปัญหาเมื่อการอ้างอิงไลบรารีมีประเภทบิลด์ ที่แอปของคุณไม่มี เนื่องจากปลั๊กอินไม่เคย ขอประเภทบิลด์นั้นจาก Dependency

    ใช้ matchingFallbacks เพื่อระบุการจับคู่สำรองสำหรับประเภทบิลด์ที่กำหนด ดังที่แสดงที่นี่

    Kotlin

    // In the app's build.gradle.kts file.
android {
    buildTypes {
        getByName("debug") {}
        getByName("release") {}
        create("staging") {
            // Specifies a sorted list of fallback build types that the
            // plugin can try to use when a dependency does not include a
            // "staging" build type. You may specify as many fallbacks as you
            // like, and the plugin selects the first build type that's
            // available in the dependency.
            matchingFallbacks += listOf("debug", "qa", "release")
        }
    }
}

    ดึงดูด

    // In the app's build.gradle file.
android {
    buildTypes {
        debug {}
        release {}
        staging {
            // Specifies a sorted list of fallback build types that the
            // plugin can try to use when a dependency does not include a
            // "staging" build type. You may specify as many fallbacks as you
            // like, and the plugin selects the first build type that's
            // available in the dependency.
            matchingFallbacks = ['debug', 'qa', 'release']
        }
    }
}

  • สำหรับมิติข้อมูลรสชาติที่กำหนดซึ่งมีอยู่ในทั้งแอปและทรัพยากร Dependency ของไลบรารี แอปจะมีรสชาติที่ไลบรารีไม่มี

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

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

    ใช้ matchingFallbacks เพื่อระบุการจับคู่ทางเลือกสำหรับเวอร์ชันผลิตภัณฑ์ "ฟรี" ของแอป ดังที่แสดงที่นี่

    Kotlin

    // In the app's build.gradle.kts file.
android {
    defaultConfig{
    // Don't configure matchingFallbacks in the defaultConfig block.
    // Instead, specify fallbacks for a given product flavor in the
    // productFlavors block, as shown below.
  }
    flavorDimensions += "tier"
    productFlavors {
        create("paid") {
            dimension = "tier"
            // Because the dependency already includes a "paid" flavor in its
            // "tier" dimension, you don't need to provide a list of fallbacks
            // for the "paid" flavor.
        }
        create("free") {
            dimension = "tier"
            // Specifies a sorted list of fallback flavors that the plugin
            // can try to use when a dependency's matching dimension does
            // not include a "free" flavor. Specify as many
            // fallbacks as you like; the plugin selects the first flavor
            // that's available in the dependency's "tier" dimension.
            matchingFallbacks += listOf("demo", "trial")
        }
    }
}

    ดึงดูด

    // In the app's build.gradle file.
android {
    defaultConfig{
    // Don't configure matchingFallbacks in the defaultConfig block.
    // Instead, specify fallbacks for a given product flavor in the
    // productFlavors block, as shown below.
  }
    flavorDimensions 'tier'
    productFlavors {
        paid {
            dimension 'tier'
            // Because the dependency already includes a "paid" flavor in its
            // "tier" dimension, you don't need to provide a list of fallbacks
            // for the "paid" flavor.
        }
        free {
            dimension 'tier'
            // Specifies a sorted list of fallback flavors that the plugin
            // can try to use when a dependency's matching dimension does
            // not include a "free" flavor. Specify as many
            // fallbacks as you like; the plugin selects the first flavor
            // that's available in the dependency's "tier" dimension.
            matchingFallbacks = ['demo', 'trial']
        }
    }
}

  • ทรัพยากร Dependency ของไลบรารีมีมิติข้อมูลรสชาติที่แอปของคุณไม่มี

    ตัวอย่างเช่น ทรัพยากร Dependency ของไลบรารีมี Flavor สำหรับมิติข้อมูล "minApi" แต่แอปของคุณ มี Flavor สำหรับมิติข้อมูล "tier" เท่านั้น เมื่อคุณต้องการสร้างแอปเวอร์ชัน "freeDebug" ปลั๊กอินจะไม่ทราบว่าจะใช้ทรัพยากร Dependency เวอร์ชัน "minApi23Debug" หรือ "minApi18Debug"

    โปรดทราบว่าไม่มีปัญหาเมื่อแอปของคุณมีมิติข้อมูลของเวอร์ชันที่ทรัพยากร Dependency ของไลบรารีไม่มี เนื่องจากปลั๊กอินจะจับคู่ Flavor ของเฉพาะมิติข้อมูลที่ อยู่ใน Dependency เช่น หากทรัพยากร Dependency ไม่มีมิติข้อมูลสำหรับ ABI แอปเวอร์ชัน "freeX86Debug" จะใช้เวอร์ชัน "freeDebug" ของ ทรัพยากร Dependency

    ใช้ missingDimensionStrategy ในบล็อก defaultConfig เพื่อระบุ รสชาติเริ่มต้นสำหรับปลั๊กอินที่จะเลือกจากมิติข้อมูลที่ขาดหายไปแต่ละรายการ ดังที่แสดงใน ตัวอย่างต่อไปนี้ คุณยังลบล้างการเลือกในproductFlavors ได้ด้วย เพื่อให้แต่ละรสชาติระบุกลยุทธ์การจับคู่ที่แตกต่างกันสำหรับมิติข้อมูลที่ขาดหายไปได้

    Kotlin

    // In the app's build.gradle.kts file.
android {
    defaultConfig{
    // Specifies a sorted list of flavors that the plugin can try to use from
    // a given dimension. This tells the plugin to select the "minApi18" flavor
    // when encountering a dependency that includes a "minApi" dimension.
    // You can include additional flavor names to provide a
    // sorted list of fallbacks for the dimension.
    missingDimensionStrategy("minApi", "minApi18", "minApi23")
    // Specify a missingDimensionStrategy property for each
    // dimension that exists in a local dependency but not in your app.
    missingDimensionStrategy("abi", "x86", "arm64")
    }
    flavorDimensions += "tier"
    productFlavors {
        create("free") {
            dimension = "tier"
            // You can override the default selection at the product flavor
            // level by configuring another missingDimensionStrategy property
            // for the "minApi" dimension.
            missingDimensionStrategy("minApi", "minApi23", "minApi18")
        }
        create("paid") {}
    }
}

    ดึงดูด

    // In the app's build.gradle file.
android {
    defaultConfig{
    // Specifies a sorted list of flavors that the plugin can try to use from
    // a given dimension. This tells the plugin to select the "minApi18" flavor
    // when encountering a dependency that includes a "minApi" dimension.
    // You can include additional flavor names to provide a
    // sorted list of fallbacks for the dimension.
    missingDimensionStrategy 'minApi', 'minApi18', 'minApi23'
    // Specify a missingDimensionStrategy property for each
    // dimension that exists in a local dependency but not in your app.
    missingDimensionStrategy 'abi', 'x86', 'arm64'
    }
    flavorDimensions 'tier'
    productFlavors {
        free {
            dimension 'tier'
            // You can override the default selection at the product flavor
            // level by configuring another missingDimensionStrategy property
            // for the 'minApi' dimension.
            missingDimensionStrategy 'minApi', 'minApi23', 'minApi18'
        }
        paid {}
    }
}

ดูข้อมูลเพิ่มเติมได้ที่ matchingFallbacks และ missingDimensionStrategy ในข้อมูลอ้างอิง DSL ของปลั๊กอิน Android Gradle

กำหนดการตั้งค่าการลงนาม

Gradle จะไม่ลงนามใน APK หรือ AAB ของบิลด์รุ่นที่เผยแพร่ เว้นแต่คุณจะกำหนดค่าการลงนามสำหรับบิลด์นี้อย่างชัดเจน หากยังไม่มีคีย์การลงนาม ให้ สร้างคีย์การอัปโหลดและที่เก็บคีย์ โดยใช้ Android Studio

หากต้องการกำหนดค่าการลงชื่อสำหรับประเภทบิลด์ที่เผยแพร่ด้วยตนเอง โดยใช้การกำหนดค่าบิลด์ Gradle ให้ทำดังนี้

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

  3. เพิ่มการกำหนดค่าการลงชื่อลงในไฟล์ build.gradle.kts ระดับโมดูล

    Kotlin

    ...
android {
    ...
    defaultConfig {...}
    signingConfigs {
        create("release") {
            storeFile = file("myreleasekey.keystore")
            storePassword = "password"
            keyAlias = "MyReleaseKey"
            keyPassword = "password"
        }
    }
    buildTypes {
        getByName("release") {
            ...
            signingConfig = signingConfigs.getByName("release")
        }
    }
}

    ดึงดูด

    ...
android {
    ...
    defaultConfig {...}
    signingConfigs {
        release {
            storeFile file("myreleasekey.keystore")
            storePassword "password"
            keyAlias "MyReleaseKey"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            ...
            signingConfig signingConfigs.release
        }
    }
}

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

วิธีรับรหัสผ่านเหล่านี้จากตัวแปรสภาพแวดล้อม

Kotlin

storePassword = System.getenv("KSTOREPWD")
keyPassword = System.getenv("KEYPWD")

ดึงดูด

storePassword System.getenv("KSTOREPWD")
keyPassword System.getenv("KEYPWD")

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

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

คำเตือน: โปรดเก็บคีย์สโตร์และคีย์ส่วนตัวไว้ในที่ที่ปลอดภัย และตรวจสอบว่าคุณได้สำรองข้อมูลดังกล่าวอย่างปลอดภัย หากใช้ Play App Signing และทำคีย์การอัปโหลดหาย คุณจะขอรีเซ็ตได้โดยใช้ Play Console หากคุณเผยแพร่แอปโดยไม่ใช้ Play App Signing (สำหรับแอปที่สร้างขึ้นก่อนเดือนสิงหาคม 2021) และทำคีย์ App Signing หาย คุณจะเผยแพร่อัปเดตแอปไม่ได้ เนื่องจากคุณต้องลงนามในแอปทุกเวอร์ชันด้วยคีย์เดียวกันเสมอ

การลงนามในแอป Wear OS

เมื่อเผยแพร่แอป Wear OS ทั้ง APK ของนาฬิกาและ APK ของโทรศัพท์ (ไม่บังคับ) ต้องลงนามด้วยคีย์เดียวกัน ดูข้อมูลเพิ่มเติมเกี่ยวกับการรวมแพ็กเกจและการลงนามแอป Wear OS ได้ที่ รวมแพ็กเกจและจัดจำหน่ายแอป Wear