android-gradle
ग्रेड के साथ अपने बिल्ड को कॉन्फ़िगर करें

टिप्पणियों

एंड्रॉइड स्टूडियो प्रोजेक्ट में दो build.gradle फाइलें क्यों हैं?

<PROJECT_ROOT>\app\build.gradle ऐप मॉड्यूल के लिए विशिष्ट है।

<PROJECT_ROOT>\build.gradle एक "टॉप-लेवल बिल्ड फ़ाइल" है जहाँ आप सभी उप-परियोजनाओं / मॉड्यूलों में कॉमन विन्यास विकल्प जोड़ सकते हैं।

यदि आप अपनी परियोजना में एक अन्य मॉड्यूल का उपयोग करते हैं, तो एक स्थानीय पुस्तकालय के रूप में आपके पास एक और build.gradle फ़ाइल होगी: <PROJECT_ROOT>\module\build.gradle

शीर्ष स्तर की बिल्ड फ़ाइल

रूट प्रोजेक्ट डायरेक्टरी में स्थित शीर्ष-स्तरीय बिल्ड.ग्रेड फ़ाइल, आपके प्रोजेक्ट में सभी मॉड्यूल पर लागू कॉन्फ़िगरेशन को परिभाषित करता है। डिफ़ॉल्ट रूप से, शीर्ष-स्तरीय बिल्ड फ़ाइल, buildscript {} block रिपॉजिटरी और निर्भरता को परिभाषित करने के लिए buildscript {} block का उपयोग करती है जो प्रोजेक्ट में सभी मॉड्यूल के लिए सामान्य हैं। निम्न कोड नमूना डिफ़ॉल्ट सेटिंग्स और डीएसएल तत्वों का वर्णन करता है जिन्हें आप एक नया प्रोजेक्ट बनाने के बाद शीर्ष-स्तर बिल्ड.ग्रेड में पा सकते हैं।

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
       classpath 'com.android.tools.build:gradle:2.2.0'
       classpath 'com.google.gms:google-services:3.0.0'
    }
}

ext {
    compileSdkVersion = 23
    buildToolsVersion = "23.0.1"
}

मॉड्यूल-स्तर बिल्ड फ़ाइल

प्रत्येक <project>/<module>/ निर्देशिका में स्थित मॉड्यूल-स्तर build.gradle फ़ाइल, आपको उस विशिष्ट मॉड्यूल के लिए बिल्ड सेटिंग्स कॉन्फ़िगर करने की अनुमति देती है जो इसमें स्थित है। इन बिल्ड सेटिंग्स को कॉन्फ़िगर करने से आप कस्टम पैकेजिंग विकल्प प्रदान कर सकते हैं, जैसे अतिरिक्त बिल्ड प्रकार और उत्पाद स्वादों के रूप में, और main/ app मेनिफ़ेस्ट या टॉप-लेवल build.gradle फ़ाइल में सेटिंग्स ओवरराइड करें।

apply plugin: 'com.android.application'


android {
    compileSdkVersion rootProject.ext.compileSdkVersion
    buildToolsVersion rootProject.ext.buildToolsVersion
}

dependencies {
    //.....
}

शीर्ष स्तर फ़ाइल उदाहरण

/**
 * The buildscript {} block is where you configure the repositories and
 * dependencies for Gradle itself--meaning, you should not include dependencies
 * for your modules here. For example, this block includes the Android plugin for
 * Gradle as a dependency because it provides the additional instructions Gradle
 * needs to build Android app modules.
 */

buildscript {

    /**
     * The repositories {} block configures the repositories Gradle uses to
     * search or download the dependencies. Gradle pre-configures support for remote
     * repositories such as JCenter, Maven Central, and Ivy. You can also use local
     * repositories or define your own remote repositories. The code below defines
     * JCenter as the repository Gradle should use to look for its dependencies.
     */

    repositories {
        jcenter()
    }

    /**
     * The dependencies {} block configures the dependencies Gradle needs to use
     * to build your project. The following line adds Android Plugin for Gradle
     * version 2.0.0 as a classpath dependency.
     */

    dependencies {
        classpath 'com.android.tools.build:gradle:2.0.0'
    }
}

/**
 * The allprojects {} block is where you configure the repositories and
 * dependencies used by all modules in your project, such as third-party plugins
 * or libraries. Dependencies that are not required by all the modules in the
 * project should be configured in module-level build.gradle files. For new
 * projects, Android Studio configures JCenter as the default repository, but it
 * does not configure any dependencies.
 */

allprojects {
   repositories {
       jcenter()
   }
}

मॉड्यूल फ़ाइल उदाहरण

/**
 * The first line in the build configuration applies the Android plugin for
 * Gradle to this build and makes the android {} block available to specify
 * Android-specific build options.
 */

apply plugin: 'com.android.application'

/**
 * The android {} block is where you configure all your Android-specific
 * build options.
 */

android {

  /**
   * compileSdkVersion specifies the Android API level Gradle should use to
   * compile your app. This means your app can use the API features included in
   * this API level and lower.
   *
   * buildToolsVersion specifies the version of the SDK build tools, command-line
   * utilities, and compiler that Gradle should use to build your app. You need to
   * download the build tools using the SDK Manager.
   */

  compileSdkVersion 23
  buildToolsVersion "23.0.3"

  /**
   * The defaultConfig {} block encapsulates default settings and entries for all
   * build variants, and can override some attributes in main/AndroidManifest.xml
   * dynamically from the build system. You can configure product flavors to override
   * these values for different versions of your app.
   */

  defaultConfig {

    /**
     * applicationId uniquely identifies the package for publishing.
     * However, your source code should still reference the package name
     * defined by the package attribute in the main/AndroidManifest.xml file.
     */

    applicationId 'com.example.myapp'

    // Defines the minimum API level required to run the app.
    minSdkVersion 14

    // Specifies the API level used to test the app.
    targetSdkVersion 23

    // Defines the version number of your app.
    versionCode 1

    // Defines a user-friendly version name for your app.
    versionName "1.0"
  }

  /**
   * The buildTypes {} block is where you can configure multiple build types.
   * By default, the build system defines two build types: debug and release. The
   * debug build type is not explicitly shown in the default build configuration,
   * but it includes debugging tools and is signed with the debug key. The release
   * build type applies Proguard settings and is not signed by default.
   */

  buildTypes {

    /**
     * By default, Android Studio configures the release build type to enable code
     * shrinking, using minifyEnabled, and specifies the Proguard settings file.
     */

    release {
        minifyEnabled true // Enables code shrinking for the release build type.
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
  }

  /**
   * The productFlavors {} block is where you can configure multiple product
   * flavors. This allows you to create different versions of your app that can
   * override defaultConfig {} with their own settings. Product flavors are
   * optional, and the build system does not create them by default. This example
   * creates a free and paid product flavor. Each product flavor then specifies
   * its own application ID, so that they can exist on the Google Play Store, or
   * an Android device, simultaneously.
   */

  productFlavors {
    free {
      applicationId 'com.example.myapp.free'
    }

    paid {
      applicationId 'com.example.myapp.paid'
    }
  }
}

/**
 * The dependencies {} block in the module-level build configuration file
 * only specifies dependencies required to build the module itself.
 */

dependencies {
    compile project(":lib")
    compile 'com.android.support:appcompat-v7:24.1.0'
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

Apk नाम बदलने के लिए archivesBaseName का उपयोग करें

आप archivesBaseName का नाम सेट करने के लिए archivesBaseName नाम का उपयोग कर सकते हैं।

उदाहरण के लिए:

  defaultConfig {
      ....
      project.ext.set("archivesBaseName", "MyName-" + defaultConfig.versionName);

  }

आपको यह आउटपुट प्राप्त होगा।

MyName-X.X.X-release.apk