एक से ज़्यादा APK बनाएं

चेतावनी: अगस्त 2021 से, सभी नए ऐप्लिकेशन, ऐप्लिकेशन बंडल के तौर पर पब्लिश किए जाने चाहिए. अगर आपने Google Play पर अपना ऐप्लिकेशन पब्लिश किया है, Android ऐप्लिकेशन बंडल बनाना और अपलोड करना. टास्क कब शुरू होगा ऐसा करने पर, Google Play आपके काम के लिए, ऑप्टिमाइज़ किए गए APKs अपने-आप जनरेट करता है और उन्हें उपलब्ध कराता है हर उपयोगकर्ता के डिवाइस कॉन्फ़िगरेशन की ज़रूरत होती है, इसलिए वे सिर्फ़ कोड और रिसॉर्स डाउनलोड करते हैं उन्हें आपका ऐप्लिकेशन चलाना होगा. एक से ज़्यादा APKs पब्लिश करना तब फ़ायदेमंद होता है, जब और ऐसे स्टोर पर पब्लिश किया जा सकता है जो एएबी फ़ॉर्मैट के साथ काम नहीं करता. इस स्थिति में, आपको आपको हर APK को खुद बनाना, साइन करना, और मैनेज करना होगा.

हालांकि अपने सभी लक्षित डिवाइस का समर्थन करने के लिए एक ही APK बनाना बेहतर होता है इसकी वजह से, हो सकता है कि APK का साइज़ बहुत बड़ा हो जाए. कई का समर्थन करता है स्क्रीन डेंसिटी या ऐप्लिकेशन बाइनरी इंटरफ़ेस (एबीआई). अपने APK का साइज़ कम करने का एक तरीका यह है कि एक से ज़्यादा APKs खास स्क्रीन डेंसिटी या एबीआई की फ़ाइलें शामिल होनी चाहिए.

Gradle अलग-अलग APK बना सकता है, जिसमें सिर्फ़ खास कोड और संसाधन ही शामिल होते हैं का इस्तेमाल किया जा सकता है. इस पेज पर बताया गया है कि अपने बिल्ड को कई APK जनरेट करते हैं. अगर आपको अपने ऐप्लिकेशन के अलग-अलग वर्शन बनाने हैं जो स्क्रीन की सघनता या एबीआई पर आधारित नहीं हैं, उनके बजाय बिल्ड वैरिएंट का इस्तेमाल करें.

एक से ज़्यादा APK के लिए अपना बिल्ड कॉन्फ़िगर करें

एक से ज़्यादा APK के लिए अपने बिल्ड कॉन्फ़िगर करने के लिए, splits आपके मॉड्यूल-लेवल पर ब्लॉक करता है build.gradle फ़ाइल. इस splits ब्लॉक, उपलब्ध कराएं density ब्लॉक तय करता है कि Gradle कैसे जनरेट करना है हर डेंसिटी वाले APK या abi ब्लॉक, जो यह बताता है कि आपको Gradle कैसे चाहिए पर-एबीआई APK जनरेट करने के लिए. सघनता और एबीआई ब्लॉक, दोनों की जानकारी दी जा सकती है और बिल्ड सिस्टम हर डेंसिटी और एबीआई के कॉम्बिनेशन के लिए APK बनाता है.

स्क्रीन डेंसिटी के लिए कई APKs कॉन्फ़िगर करना

अलग-अलग स्क्रीन डेंसिटी के लिए अलग-अलग APK बनाने के लिए, आपके अंदर density ब्लॉक splits ब्लॉक. अपने density ब्लॉक में, यह जानकारी दें: और इसके साथ काम करने वाली स्क्रीन डेंसिटी की सूची देखें. सिर्फ़ इसकी सूची इस्तेमाल करें अगर ज़रूरत हो, तो संगत स्क्रीन आकार हर APK के मेनिफ़ेस्ट में <compatible-screens> एलिमेंट शामिल होते हैं.

Gradle DSL के नीचे दिए गए विकल्पों का इस्तेमाल, स्क्रीन डेंसिटी:

ग्रूवी के लिए enable, Kotlin स्क्रिप्ट के लिए isEnable
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है अगर इस एलिमेंट को true पर सेट किया जाता है, तो Gradle कई APKs जनरेट करता है तय करें. डिफ़ॉल्ट मान यह है false.
exclude
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यह डेंसिटी की कॉमा-सेपरेटेड लिस्ट बनाता है, जिसे Gradle नहीं इस्तेमाल करना चाहिए अलग-अलग APK जनरेट करें. exclude का इस्तेमाल करें, अगर ज़्यादातर डेंसिटी के लिए APK जनरेट करना चाहते हैं, लेकिन इनमें से कुछ को छोड़ना होगा डेंसिटी (सघनता) जो आपके ऐप्लिकेशन पर काम नहीं करती.
reset()

इस नीति की मदद से, स्क्रीन डेंसिटी की डिफ़ॉल्ट सूची को हटाया जाता है. इसे सिर्फ़ तब इस्तेमाल करें, जब include एलिमेंट, जिसकी मदद से आपको डेंसिटी तय करनी है जोड़ें.

निम्न स्निपेट डेंसिटी की सूची को केवल reset() पर कॉल करके ldpi और xxhdpi सूची को मिटाने और फिर include का इस्तेमाल करने के लिए:

reset()                  // Clears the default list from all densities
                         // to no densities.
include "ldpi", "xxhdpi" // Specifies the two densities to generate APKs
                         // for.
include
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यह डेंसिटी की कॉमा-सेपरेटेड लिस्ट बनाता है, जिसे आपको Gradle जनरेट करना है APK के लिए. सिर्फ़ reset() के साथ इस्तेमाल करके तय करें कि डेंसिटी की सटीक सूची.
compatibleScreens

इस नीति से, काम करने वाले स्क्रीन साइज़ की ऐसी सूची के बारे में पता चलता है जिसे कॉमा लगाकर अलग किया गया हो. यह इंजेक्ट करता है मेल खाने वाला इसके लिए मेनिफ़ेस्ट में <compatible-screens> नोड हर APK के लिए उपलब्ध है.

इस सेटिंग से, दोनों स्क्रीन को आसानी से मैनेज किया जा सकता है डेंसिटी और स्क्रीन साइज़, दोनों एक ही build.gradle सेक्शन में होते हैं. हालांकि, <compatible-screens> पर यह तय किया जा सकता है कि डिवाइस किस तरह का होगा आपके ऐप्लिकेशन के साथ काम करता है. अलग-अलग स्क्रीन साइज़, स्क्रीन के साथ काम करने की खास जानकारी.

क्योंकि स्क्रीन की सघनता पर आधारित हर APK में खास पाबंदियों वाला <compatible-screens> टैग इस बारे में जानकारी कि APK किस तरह की स्क्रीन पर काम करता है—भले ही, आप कई स्क्रीन टाइप APK—कुछ नए डिवाइस आपके एक से ज़्यादा APK फ़िल्टर से मेल नहीं खाते हैं. इसलिए, Gradle हमेशा एक और यूनिवर्सल APK जनरेट करता है, जिसमें ऐसेट होती हैं के लिए सही है. साथ ही, इसमें <compatible-screens> टैग. इसे प्रकाशित करें आपके हर डेंसिटी वाले APK के साथ-साथ यूनिवर्सल APK, ताकि वे डिवाइस जिनका APK <compatible-screens> टैग.

नीचे दिया गया उदाहरण हर एक के लिए एक अलग APK जनरेट करता है स्क्रीन डेंसिटी, इसमें ldpi, xxhdpi, और शामिल नहीं हैं xxxhdpi. ऐसा करने के लिए, exclude का इस्तेमाल करके इसे हटाया जाता है सभी डेंसिटी की डिफ़ॉल्ट सूची से वे तीन डेंसिटी.

ग्रूवी

android {
  ...
  splits {

    // Configures multiple APKs based on screen density.
    density {

      // Configures multiple APKs based on screen density.
      enable true

      // Specifies a list of screen densities you don't want Gradle to create multiple APKs for.
      exclude "ldpi", "xxhdpi", "xxxhdpi"

      // Specifies a list of compatible screen size settings for the manifest.
      compatibleScreens 'small', 'normal', 'large', 'xlarge'
    }
  }
}

Kotlin

android {
    ...
    splits {

        // Configures multiple APKs based on screen density.
        density {

            // Configures multiple APKs based on screen density.
            isEnable = true

            // Specifies a list of screen densities you don't want Gradle to create multiple APKs for.
            exclude("ldpi", "xxhdpi", "xxxhdpi")

            // Specifies a list of compatible screen size settings for the manifest.
            compatibleScreens("small", "normal", "large", "xlarge")
        }
    }
}

अलग-अलग बिल्ड को पसंद के मुताबिक बनाने के बारे में ज़्यादा जानकारी पाने के लिए खास स्क्रीन टाइप और डिवाइसों के लिए अपने ऐप्लिकेशन के अलग-अलग वैरिएंट के लिए, देखें एलान करें कि पाबंदी लगी है स्क्रीन सहायता.

एबीआई के लिए एक से ज़्यादा APKs कॉन्फ़िगर करना

अलग-अलग एबीआई के लिए अलग-अलग APK बनाने के लिए, abi ब्लॉक जोड़ें CANNOT TRANSLATE splits ब्लॉक. अपने abi ब्लॉक में, इनकी सूची दें शामिल करने की ज़रूरत होती है.

नीचे दिए गए Gradle DSL से जुड़े विकल्पों का इस्तेमाल, हर APK के लिए एक से ज़्यादा APK कॉन्फ़िगर करने के लिए किया जाता है एबीआई:

ग्रूवी के लिए enable या Kotlin स्क्रिप्ट के लिए isEnable
अगर इस एलिमेंट को true पर सेट किया जाता है, तो Gradle कई इमेज जनरेट करेगा आपके तय किए गए एबीआई पर आधारित APKs. डिफ़ॉल्ट वैल्यू false है.
exclude
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यह नीति, कॉमा लगाकर अलग की गई एबीआई की ऐसी सूची के बारे में बताती है जिसे Gradle नहीं करना है अलग-अलग APK जनरेट करें. अगर आपको जनरेट करना है, तो exclude का इस्तेमाल करें ज़्यादातर एबीआई के लिए APK, लेकिन कुछ ऐसे एबीआई को निकालने की ज़रूरत है जो आपका ऐप्लिकेशन नहीं करते सहायता.
reset()

एबीआई की डिफ़ॉल्ट सूची को हटाता है. इसे सिर्फ़ तब इस्तेमाल करें, जब include एलिमेंट शामिल करें, ताकि जिन एबीआई को जोड़ना हो उनके बारे में बताया जा सके.

नीचे दिया गया स्निपेट एबीआई की सूची को सिर्फ़ x86 पर सेट करता है और सूची मिटाने के लिए, reset() पर कॉल करके x86_64 और इसके बाद, include का इस्तेमाल करके:

reset()                 // Clears the default list from all ABIs to no ABIs.
include "x86", "x86_64" // Specifies the two ABIs we want to generate APKs for.
include
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यह नीति, कॉमा लगाकर अलग की गई एबीआई की ऐसी सूची के बारे में बताती है जिसे आपको Gradle से APK जनरेट कराना है के लिए. सिर्फ़ reset() के साथ इस्तेमाल करके सटीक वैल्यू पाएं की सूची उपलब्ध है.
ग्रूवी के लिए universalApk या इसके लिए isUniversalApk Kotlin स्क्रिप्ट

अगर true, तो Gradle इसके अलावा एक यूनिवर्सल APK भी जनरेट करता है हर ABI APK के हिसाब से. यूनिवर्सल APK में, सभी एबीआई के कोड और संसाधन के लिए उपलब्ध है. डिफ़ॉल्ट वैल्यू false है.

ध्यान दें कि यह विकल्प सिर्फ़ splits.abi ब्लॉक में उपलब्ध है. एक से ज़्यादा APK बनाते समय स्क्रीन की डेंसिटी के हिसाब से, Gradle हमेशा एक यूनिवर्सल APK जनरेट करता है, जो इसमें सभी स्क्रीन डेंसिटी के लिए कोड और संसाधन मौजूद होते हैं.

नीचे दिया गया उदाहरण हर एबीआई के लिए अलग APK जनरेट करता है: x86 और x86_64. ऐसा reset() का इस्तेमाल करके किया जाता है एबीआई की एक खाली सूची से शुरू करें, इसके बाद include एबीआई की सूची जिसे हर APK मिलता है.

ग्रूवी

android {
  ...
  splits {

    // Configures multiple APKs based on ABI.
    abi {

      // Enables building multiple APKs per ABI.
      enable true

      // By default all ABIs are included, so use reset() and include to specify that you only
      // want APKs for x86 and x86_64.

      // Resets the list of ABIs for Gradle to create APKs for to none.
      reset()

      // Specifies a list of ABIs for Gradle to create APKs for.
      include "x86", "x86_64"

      // Specifies that you don't want to also generate a universal APK that includes all ABIs.
      universalApk false
    }
  }
}

Kotlin

android {
  ...
  splits {

    // Configures multiple APKs based on ABI.
    abi {

      // Enables building multiple APKs per ABI.
      isEnable = true

      // By default all ABIs are included, so use reset() and include to specify that you only
      // want APKs for x86 and x86_64.

      // Resets the list of ABIs for Gradle to create APKs for to none.
      reset()

      // Specifies a list of ABIs for Gradle to create APKs for.
      include("x86", "x86_64")

      // Specifies that you don't want to also generate a universal APK that includes all ABIs.
      isUniversalApk = false
    }
  }
}

इस्तेमाल किए जा सकने वाले एबीआई की सूची देखने के लिए, यहां देखें काम करता है एबीआई.

बिना नेटिव/C++ कोड वाले प्रोजेक्ट

नेटिव/C++ कोड वाले प्रोजेक्ट के लिए, वैरिएंट बनाएं पैनल में दो विकल्प होते हैं कॉलम: मॉड्यूल और ऐक्टिव बिल्ड वैरिएंट, जैसा कि पहली इमेज में दिखाया गया है.


बिल्ड वैरिएंट का पैनल पहली इमेज. वैरिएंट बनाएं पैनल में, बिना वर्शन वाले प्रोजेक्ट के लिए दो कॉलम होते हैं नेटिव/C++ कोड.

इस वैल्यू के लिए, ऐक्टिव बिल्ड वैरिएंट की वैल्यू मॉड्यूल से वह बिल्ड वैरिएंट तय होता है जो एडिटर में डिप्लॉय किया जाता है और दिखता है. वैरिएंट के बीच स्विच करने के लिए, किसी मॉड्यूल के ऐक्टिव बिल्ड वैरिएंट सेल पर क्लिक करें और सूची फ़ील्ड से पसंदीदा वैरिएंट चुनें.

नेटिव/C++ कोड वाले प्रोजेक्ट

नेटिव/C++ कोड वाले प्रोजेक्ट के लिए, अलग-अलग वर्शन बनाएं पैनल में तीन तरह के वैरिएंट होते हैं कॉलम: मॉड्यूल, ऐक्टिव बिल्ड वैरिएंट और ऐक्टिव एबीआई, जैसा कि दूसरी इमेज में दिखाया गया है.

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है दूसरी इमेज. वैरिएंट बनाने वाला पैनल, इनके लिए चालू एबीआई कॉलम जोड़ता है नेटिव/C++ कोड वाले प्रोजेक्ट.

मॉड्यूल के लिए ऐक्टिव बिल्ड वैरिएंट की वैल्यू इसकी मदद से, डिप्लॉय किए गए बिल्ड वैरिएंट का पता चलता है और यह एडिटर में दिखता है. नेटिव मॉड्यूल के लिए, चालू एबीआई वैल्यू से, एबीआई तय होता है कि एडिटर इस्तेमाल करता है, लेकिन डिप्लॉय किए गए वर्शन पर इसका कोई असर नहीं पड़ता.

बिल्ड टाइप या एबीआई बदलने के लिए:

  1. ऐक्टिव बिल्ड वैरिएंट के सेल पर क्लिक करें या चालू एबीआई कॉलम चुनें.
  2. सूची से पसंदीदा वैरिएंट या एबीआई चुनें फ़ील्ड में डालें. नया सिंक अपने-आप चलता है.

किसी ऐप्लिकेशन या लाइब्रेरी मॉड्यूल के किसी भी कॉलम में बदलाव करने पर, बदलाव सभी निर्भर पंक्तियां.

वर्शन कॉन्फ़िगर करें

डिफ़ॉल्ट रूप से, जब Gradle कई APK जनरेट करता है, तो हर APK एक जैसा होता है वर्शन की जानकारी, जैसा कि मॉड्यूल-लेवल में बताया गया है build.gradle या build.gradle.kts फ़ाइल. क्योंकि Google Play स्टोर, समान ऐप्लिकेशन के लिए कई APK की अनुमति नहीं देता है जिनमें सभी में एक जैसी वर्शन जानकारी है, तो आपको यह पक्का करना होगा कि हर APK का आपको Play Store पर अपलोड करने से पहले, versionCode देने होंगे.

मॉड्यूल-लेवल की build.gradle फ़ाइल को यहां कॉन्फ़िगर किया जा सकता है हर APK के लिए versionCode को बदलें. मैपिंग बनाकर जो कॉन्फ़िगर किए गए हर एबीआई और डेंसिटी के लिए यूनीक न्यूमेरिक वैल्यू असाइन करता है के लिए, एक से ज़्यादा APK के लिए, आप आउटपुट वर्शन कोड को defaultConfig में तय किए गए वर्शन कोड को जोड़ता है या productFlavors ब्लॉक को, संख्या वाली वैल्यू के साथ असाइन किया गया है सघनता या एबीआई.

नीचे दिए गए उदाहरण में, x86 एबीआई का APK 2004 का versionCode और x86_64 एबीआई मिलता है 3004 का versionCode मिलता है.

बड़े पैमाने पर वर्शन कोड असाइन करने से, जैसे कि 1, 000 को तय करने की अनुमति मिलती है अगर आपको अपना ऐप्लिकेशन अपडेट करना है, तो बाद में यूनीक वर्शन कोड असाइन करें. इसके लिए उदाहरण के लिए, अगर defaultConfig.versionCode बाद में होने वाले अपडेट के बाद, Gradle, 2005 का versionCode x86 APK और 3005 से x86_64 APK तक.

सलाह: अगर आपके बिल्ड में यूनिवर्सल APK शामिल है, तो उसे versionCode है, जो आपके किसी भी अन्य APK से कम है. क्योंकि Google Play Store आपके ऐप्लिकेशन का वर्शन इंस्टॉल करता है, जो कि टारगेट डिवाइस के साथ काम करता है और उसकी सबसे ज़्यादा वैल्यू versionCode, कम से कम versionCode असाइन करते समय यूनिवर्सल APK यह पक्का करता है कि Google Play Store आपके APK को यूनिवर्सल APK पर वापस ले जाने से पहले बनाना ज़रूरी है. नीचे दिया गया सैंपल कोड यूनिवर्सल APK के ओवरराइड किए बिना इसे मैनेज करता है डिफ़ॉल्ट versionCode.

ग्रूवी

android {
  ...
  defaultConfig {
    ...
    versionCode 4
  }
  splits {
    ...
  }
}

// Map for the version code that gives each ABI a value.
ext.abiCodes = ['armeabi-v7a':1, x86:2, x86_64:3]

// For per-density APKs, create a similar map:
// ext.densityCodes = ['mdpi': 1, 'hdpi': 2, 'xhdpi': 3]

import com.android.build.OutputFile

// For each APK output variant, override versionCode with a combination of
// ext.abiCodes * 1000 + variant.versionCode. In this example, variant.versionCode
// is equal to defaultConfig.versionCode. If you configure product flavors that
// define their own versionCode, variant.versionCode uses that value instead.
android.applicationVariants.all { variant ->

  // Assigns a different version code for each output APK
  // other than the universal APK.
  variant.outputs.each { output ->

    // Stores the value of ext.abiCodes that is associated with the ABI for this variant.
    def baseAbiVersionCode =
            // Determines the ABI for this variant and returns the mapped value.
            project.ext.abiCodes.get(output.getFilter(OutputFile.ABI))

    // Because abiCodes.get() returns null for ABIs that are not mapped by ext.abiCodes,
    // the following code doesn't override the version code for universal APKs.
    // However, because you want universal APKs to have the lowest version code,
    // this outcome is desirable.
    if (baseAbiVersionCode != null) {

      // Assigns the new version code to versionCodeOverride, which changes the
      // version code for only the output APK, not for the variant itself. Skipping
      // this step causes Gradle to use the value of variant.versionCode for the APK.
      output.versionCodeOverride =
              baseAbiVersionCode * 1000 + variant.versionCode
    }
  }
}

Kotlin

android {
  ...
  defaultConfig {
    ...
    versionCode = 4
  }
  splits {
    ...
  }
}

// Map for the version code that gives each ABI a value.
val abiCodes = mapOf("armeabi-v7a" to 1, "x86" to 2, "x86_64" to 3)

// For per-density APKs, create a similar map:
// val densityCodes = mapOf("mdpi" to 1, "hdpi" to 2, "xhdpi" to 3)

import com.android.build.api.variant.FilterConfiguration.FilterType.*

// For each APK output variant, override versionCode with a combination of
// abiCodes * 1000 + variant.versionCode. In this example, variant.versionCode
// is equal to defaultConfig.versionCode. If you configure product flavors that
// define their own versionCode, variant.versionCode uses that value instead.
androidComponents {
    onVariants { variant ->

        // Assigns a different version code for each output APK
        // other than the universal APK.
        variant.outputs.forEach { output ->
            val name = output.filters.find { it.filterType == ABI }?.identifier

            // Stores the value of abiCodes that is associated with the ABI for this variant.
            val baseAbiCode = abiCodes[name]
            // Because abiCodes.get() returns null for ABIs that are not mapped by ext.abiCodes,
            // the following code doesn't override the version code for universal APKs.
            // However, because you want universal APKs to have the lowest version code,
            // this outcome is desirable.
            if (baseAbiCode != null) {
                // Assigns the new version code to output.versionCode, which changes the version code
                // for only the output APK, not for the variant itself.
                output.versionCode.set(baseAbiCode * 1000 + (output.versionCode.get() ?: 0))
            }
        }
    }
}

वैकल्पिक वर्शन कोड स्कीम के ज़्यादा उदाहरणों के लिए, देखें वर्शन कोड असाइन करना.

एक से ज़्यादा APK बनाएं

मॉड्यूल-लेवल build.gradle को कॉन्फ़िगर करने के बाद या कई APK बनाने के लिए build.gradle.kts फ़ाइल, क्लिक करें बिल्ड > इस समय के सभी APK बनाने के लिए, APK बनाएं प्रोजेक्ट पैनल में चुना गया मॉड्यूल. Gradle, APK बनाता है प्रोजेक्ट के build/outputs/apk/ में हर सघनता या एबीआई के लिए डायरेक्ट्री.

Gradle, हर उस सघनता या एबीआई के लिए एक APK बनाता है जिसके लिए आप कई APK कॉन्फ़िगर करते हैं. अगर आपने डेंसिटी और एबीआई, दोनों के लिए एक से ज़्यादा APK चालू किए हैं, तो Gradle एक APK बनाता है का इस्तेमाल किया जाता है.

उदाहरण के लिए, निम्न build.gradle स्निपेट की मदद से, mdpi के लिए कई APK बनाए जा सकते हैं और hdpi डेंसिटी के साथ-साथ x86 और x86_64 एबीआई:

ग्रूवी

...
  splits {
    density {
      enable true
      reset()
      include "mdpi", "hdpi"
    }
    abi {
      enable true
      reset()
      include "x86", "x86_64"
    }
  }

Kotlin

...
  splits {
    density {
      isEnable = true
      reset()
      include("mdpi", "hdpi")
    }
    abi {
      isEnable = true
      reset()
      include("x86", "x86_64")
    }
  }

उदाहरण के कॉन्फ़िगरेशन के आउटपुट में ये चार APK शामिल होते हैं:

  • app-hdpiX86-release.apk: इसमें कोड और संसाधन शामिल हैं hdpi सघनता और x86 एबीआई.
  • app-hdpiX86_64-release.apk: इसमें कोड और संसाधन शामिल हैं hdpi सघनता और x86_64 एबीआई.
  • app-mdpiX86-release.apk: इसमें कोड और संसाधन शामिल हैं mdpi सघनता और x86 एबीआई.
  • app-mdpiX86_64-release.apk: इसमें कोड और संसाधन शामिल हैं mdpi सघनता और x86_64 एबीआई.

स्क्रीन की डेंसिटी के हिसाब से कई APK बनाते समय, Gradle हमेशा एक यूनिवर्सल APK जनरेट करता है, जिसमें सभी डेंसिटी के लिए कोड और संसाधन शामिल होते हैं, में हर डेंसिटी वाले APK के अलावा कोई दूसरा वर्शन भी हो सकता है.

अलग-अलग ऐप्लिकेशन के हिसाब से बनाए गए एक से ज़्यादा APK बनाते समय एबीआई, Gradle सिर्फ़ एक APK जनरेट करता है, जिसमें सभी के लिए कोड और संसाधन शामिल होते हैं एबीआई, अगर आपने इसमें universalApk true को तय किया है आपकी build.gradle फ़ाइल में splits.abi ब्लॉक किया गया (ग्रूवी के लिए) या isUniversalApk = true आपकी build.gradle.kts फ़ाइल में splits.abi ब्लॉक किया गया (Kotlin स्क्रिप्ट के लिए).

APK फ़ाइल के नाम का फ़ॉर्मैट

एक से ज़्यादा APK बनाते समय, Gradle, इन चीज़ों का इस्तेमाल करके APK फ़ाइल नाम जनरेट करता है स्कीम:

modulename-screendensityABI-buildvariant.apk

स्कीम के कॉम्पोनेंट:

modulename
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है बनाए जा रहे मॉड्यूल का नाम बताता है.
screendensity
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है अगर स्क्रीन सघनता के लिए एक से ज़्यादा APK चालू हैं, तो स्क्रीन की जानकारी देता है APK के लिए सघनता, जैसे mdpi.
ABI

अगर एबीआई के लिए एक से ज़्यादा APK चालू हैं, तो APK के लिए एबीआई के बारे में बताता है, जैसे x86 के तौर पर.

अगर स्क्रीन की सघनता और एबीआई, दोनों के लिए एक से ज़्यादा APKs चालू हों, तो Gradle, डेंसिटी के नाम को एबीआई के नाम के साथ जोड़ता है, उदाहरण के लिए mdpiX86. अगर universalApk, प्रति-एबीआई के लिए चालू है APK, Gradle, यूनिवर्सल APK के एबीआई वाले हिस्से के तौर पर universal का इस्तेमाल करता है फ़ाइल नाम.

buildvariant
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इससे पता चलता है कि बिल्ड का कौनसा वैरिएंट बनाया जा रहा है, जैसे कि debug.

उदाहरण के लिए, जब किसी फ़ाइल के लिए mdpi स्क्रीन सघनता वाला APK बनाया जाता है myApp का डीबग वर्शन है, तो APK फ़ाइल का नाम myApp-mdpi-debug.apk. रिलीज़ myApp का एक वर्शन है, जिसे mdpi स्क्रीन सघनता और x86 एबीआई का APK फ़ाइल नाम है myApp-mdpiX86-release.apk.