Skip to content

Most visited

Recently visited

navigation

Resep dan Tips Gradle

Gradle dan Android plugin untuk Gradle menyediakan cara yang fleksibel untuk mengompilasi, membangun, dan mengemas aplikasi atau library Android Anda. Halaman ini mengumpulkan beberapa tips dan konfigurasi yang penting untuk membantu Anda memaksimalkan hasil dari masing-masing build. Bila Anda ingin mempelajari cara mempercepat build, silakan baca Mengoptimalkan Kecepatan Build Anda.

Jika Anda baru mengenal Gradle, pelajari dasar-dasarnya dengan membaca Mengonfigurasi Build Anda. Anda juga bisa memeriksa dokumentasi referensi DSL Android plugin untuk mempelajari lebih lanjut tentang properti yang digunakan dalam halaman ini.

Mengelola project dan sumber

Berikut adalah beberapa konfigurasi untuk mengelola modul project dan sumbernya. Untuk mempelajari lebih lanjut tentang pembuatan dan pengelolaan project dan modul, baca Ringkasan Project.

Mengubah konfigurasi set sumber default

Anda bisa menggunakan blok sourceSets di file build.gradle tingkat-modul untuk mengubah lokasi Gradle mengumpulkan file untuk setiap komponen dari set sumber.

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']

      // When you list multiple directories, Gradle uses all of them to collect
      // sources. You should avoid specifying a directory which is a parent to one
      // or more other directories you specify.
      res.srcDirs = ['other/res1', 'other/res2']

      // For each source set, you can specify only one Android manifest.
      // The following points Gradle to a different manifest for this source set.
      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'
      ...
    }
  }
}
...

Mengonfigurasi properti lingkup-project

Untuk project yang mencakup beberapa modul, kami sarankan agar menentukan properti di tingkat project dan membagikannya ke semua modul. Anda bisa melakukan ini dengan menambahkan properti tambahan ke blok ext di file build.gradle tingkat atas.

buildscript {...}
allprojects {...}

// This block encapsulates custom properties and makes them available to all
// modules in the project.
ext {
    // The following are only a few examples of the types of properties you can define.
    compileSdkVersion = 26
    buildToolsVersion = "27.0.3"

    // You can also use this to specify versions for dependencies. Having consistent
    // versions between modules can avoid behavior conflicts.
    supportLibVersion = "27.0.2"
    ...
}
...

Untuk mengakses properti-properti ini dari modul dalam project yang sama, gunakan sintaks berikut pada file build.gradletingkat modul.

android {
  // Use the following syntax to access properties you defined at the project level:
  // rootProject.ext.property_name
  compileSdkVersion rootProject.ext.compileSdkVersion
  buildToolsVersion rootProject.ext.buildToolsVersion
  ...
}
...
dependencies {
    compile "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
    ...
}

Mengelola library dan dependensi

Gradle menyediakan mekanisme yang kuat untuk mengelola dependensi, baik library jarak jauh atau modul library lokal.

Menargetkan build tertentu dengan konfigurasi dependensi

Bila Anda menginginkan dependensi hanya untuk set sumber varian build tertentu atau set sumber pengujian, gunakan huruf kapital untuk nama konfigurasi dependensi dan berikan awalan nama varian build atau set sumber pengujian.

android {...}

// Creates Gradle dependency configurations to use in the dependencies block.
configurations {
  // For variants that combine a product flavor and build type, you need to
  // intitialize a placeholder for its dependency configuration.
  freeDebugApk {}
  ...
}

dependencies {
    // Adds a compile dependency only to the "free" product flavor.
    freeCompile 'com.google.firebase:firebase-ads:9.8.0'
    // Adds an apk dependency only to the "freeDebug" build variant.
    freeDebugApk fileTree(dir: 'libs', include: ['*.jar'])
    // Adds a remote binary dependency only for local tests.
    testCompile 'junit:junit:4.12'
    // Adds a remote binary dependency only for the instrumented test APK.
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

Menerbitkan varian non-default dari library Anda

Anda bisa mengubah varian library default yang diterbitkan Gradle ke modul lain dengan menambahkan kode berikut ke file build.gradle library:

android {
  ...
  // If the library configures product flavors, you must specify
  // a build variant by its full configuration name. The following
  // sets the "demoDebug" build variant as the default version
  // of the library that Gradle should publish.
  defaultPublishConfig "demoDebug"
}

Anda juga bisa memberi tahu Gradle untuk menerbitkan semua varian library yang ada.

android {
  ...
  // Note that this might increase build times because Gradle must
  // build multiple AARs, instead of only one.
  publishNonDefault true
}

Dengan menyetel publishNonDefault true, Anda bisa mengonfigurasi file build.gradle modul aplikasi sehingga masing-masing varian hanya menggunakan versi library yang dibutuhkannya.

android {...}
...

// Creates Gradle dependency configurations to use in the dependencies block.
configurations {
  // Initializes placeholders for the demoDebugCompile and fullReleaseCompile
  // dependency configurations.
  demoDebugCompile {}
  fullReleaseCompile {}
  ...
}

dependencies {
  // If the library configures multiple build variants using product flavors,
  // you must target one of the library's variants using its full configuration name.
  demoDebugCompile project(path: ':my-library-module', configuration: 'demoDebug')
  fullReleaseCompile project(path: ':my-library-module', configuration: 'fullRelease')
  ...
}

Membuat berbagai versi aplikasi

Gradle dan Android plugin memungkinkan Anda membuat berbagai versi aplikasi dari sebuah modul dengan mengonfigurasi varian build.

Mengonfigurasi dukungan multi-APK

Dengan Android plugin, Anda bisa membangun multi-APK yang masing-masing menargetkan ABI atau kepadatan layar, dan memanfaatkan dukungan multi-APK Google Play.

Mengonfigurasi APK terpisah untuk tiap kepadatan layar

Untuk membuat APK terpisah bagi beragam kepadatan layar, tambahkan blok android.splits.density ke file build.gradle modul Anda.

android {
  ...
  splits {

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

      // Enables building multiple APKs.
      enable true

      // Specifies a list of screen densities Gradle should not create APKs for.
      exclude "ldpi", "mdpi"

      // Alternatively, you can use the following to clear the default list of
      // screen densities and specify only the screen densities you want to build
      // APKs for:
      // reset()
      // include "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"

      // Specifies a list of compatible screen size settings. This property
      // configures the <compatible-screens> element in the manifest. You
      // typically don't need to configure this manifest property, but it's
      // important when building multiple APKs based on screen density.
      compatibleScreens 'normal', 'large', 'xlarge'
    }
  }
}

Mengonfigurasi APK terpisah untuk tiap ABI

Untuk membuat APK terpisah bagi setiap ABI, tambahkan blok android.splits.abi ke file build.gradle modul Anda.

android {
  ...
  splits {

    // Configures multiple APKs based on ABI.
    abi {

      // Enables building multiple APKs.
      enable true

      // By default all ABIs are included, so use reset() and include to specify that we only
      // want APKs for x86, armeabi-v7a, and mips.
      reset()

      // Specifies a list of ABIs that Gradle should create APKs for.
      include "x86", "armeabi-v7a", "mips"

      // Specify that we want to also generate a universal APK that includes all ABIs.
      universalApk true
    }
  }
}

Mengonfigurasi kode versi dinamis

Secara default, saat Gradle menghasilkan APK untuk project Anda, setiap APK memiliki informasi versi yang sama, seperti yang ditetapkan dalam file build.gradle tingkat modul. Karena Google Play Store tidak mengizinkan multi-APK untuk aplikasi yang sama jika semuanya memiliki informasi versi yang sama, Anda harus memastikan setiap APK memiliki versionCode yang unik sebelum menguploadnya ke Play Store.

Anda bisa melakukan ini dengan logika build khusus yang memberikan kode versi yang berbeda ke setiap APK pada waktu build. Misalnya, saat membuat APK terpisah untuk setiap ABI, pemberian versi APK secara otomatis akan terlihat seperti ini:

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

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

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

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 does not override the version code for universal APKs.
    // However, because we 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 simply
      // causes Gradle to use the value of variant.versionCode for the APK.
      output.versionCodeOverride =
              baseAbiVersionCode * 1000 + variant.versionCode
    }
  }
}

Menggabungkan beberapa ragam produk

Dalam beberapa kasus, Anda mungkin perlu menggabungkan konfigurasi dari beberapa ragam produk. Untuk melakukannya, Android Plugin for Gradle memungkinkan Anda membuat grup ragam produk, yang disebut dimensi ragam.

Contoh kode berikut menggunakan properti flavorDimensions untuk membuat dimensi ragam "mode" guna mengelompokkan ragam produk "full" dan "demo", serta dimensi ragam "api" untuk mengelompokkan konfigurasi ragam produk berdasarkan API level. Gradle kemudian menggabungkan ragam produk dari dimensi "mode" dengan dimensi "api".

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

  // Specifies the flavor dimensions you want to use. The order in which you
  // list each dimension determines its 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 above--the first dimension has 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. To learn more about assigning version codes to
      // support app updates and uploading to Google Play, read Multiple APK Support
      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"
      ...
    }
  }
}
...

Memfilter varian

Anda bisa memfilter varian build yang tidak Anda inginkan menggunakan blok variantFilter di file build.gradle modul. Contoh kode berikut memberi tahu Gradle untuk tidak membangun varian yang menggabungkan ragam produk "minApi21" dan "demo":

android {
 ...
 buildTypes {...}

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

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

Menguji aplikasi Anda

Untuk mempelajari lebih lanjut tentang menjalankan pengujian unit lokal dan terpadu, baca Menguji Aplikasi Anda.

Mengonfigurasi opsi lint

Anda bisa mengonfigurasi opsi lint tertentu menggunakan blok lintOptions di file build.gradle tingkat modul. Untuk mempelajari lebih lanjut tentang penggunaan lint bagi project Android Anda, baca Memperbaiki Kode Anda dengan Lint.

android {
  ...
  lintOptions {
    // Turns off checks for the issue IDs you specify.
    disable 'TypographyFractions','TypographyQuotes'
    // Turns on checks for the issue IDs you specify. These checks are in
    // addition to the default lint checks.
    enable 'RtlHardcoded', 'RtlCompat', 'RtlEnabled'
    // To enable checks for only a subset of issue IDs and ignore all others,
    // list the issue IDs with the 'check' property instead. This property overrides
    // any issue IDs you enable or disable using the properties above.
    check 'NewApi', 'InlinedApi'
    // If set to true, turns off analysis progress reporting by lint.
    quiet true
    // if set to true (default), stops the build if errors are found.
    abortOnError false
    // if true, only report errors.
    ignoreWarnings true
  }
}
...

Mengonfigurasi setelan manifes instrumentasi

Saat Gradle membangun APK pengujian Anda, Gradle secara otomatis menghasilkan file AndroidManifest.xml dan mengonfigurasinya dengan node <instrumentation>. Anda bisa mengubah beberapa setelan untuk node ini dengan membuat file manifes lain dalam set sumber pengujian atau mengonfigurasi file build.gradle tingkat modul Anda, seperti yang ditunjukkan pada contoh kode berikut.

android {
  ...
  // Each product flavor you configure can override properties in the
  // defaultConfig block. To learn more, go to Configure Product Flavors.
  defaultConfig {
    ...
    // Specifies the application ID for the test APK.
    testApplicationId "com.test.foo"
    // Specifies the fully-qualified class name of the test instrumentation runner.
    testInstrumentationRunner "android.test.InstrumentationTestRunner"
    // If set to 'true', enables the instrumentation class to start and stop profiling.
    // If set to false (default), profiling occurs the entire time the instrumentation
    // class is running.
    testHandleProfiling true
    // If set to 'true', indicates that the Android system should run the instrumentation
    // class as a functional test. The default value is 'false'
    testFunctionalTest true
  }
}
...

Mengubah tipe build pengujian

Secara default, semua pengujian dijalankan terhadap tipe build debug. Anda bisa mengubahnya ke tipe build lain dengan menggunakan properti testBuildType dalam file build.gradle tingkat modul. Misalnya jika Anda ingin menjalankan pengujian terhadap tipe build "staging", edit file tersebut seperti yang ditampilkan dalam cuplikan berikut.

android {
    ...
    testBuildType "staging"
}

Mengonfigurasi opsi pengujian Gradle

Untuk menetapkan opsi yang mengubah cara Gradle menjalankan semua pengujian Anda, lakukan konfigurasi blok testOptions di build.gradle tingkat modul.

android {
  ...
  // Encapsulates options for running tests.
  testOptions {
    // Changes the directory where Gradle saves test reports. By default, Gradle saves test reports
    // in the path_to_your_project/module_name/build/outputs/reports/ directory.
    // '$rootDir' sets the path relative to the root directory of the current project.
    reportDir "$rootDir/test-reports"
    // Changes the directory where Gradle saves test results. By default, Gradle saves test results
    // in the path_to_your_project/module_name/build/outputs/test-results/ directory.
    // '$rootDir' sets the path relative to the root directory of the current project.
    resultsDir "$rootDir/test-results"
  }
}

Untuk menetapkan opsi bagi pengujian unit lokal saja, lakukan konfigurasi blok testOptions.unitTests.

android {
  ...
  testOptions {
    ...
    // Encapsulates options for local unit tests.
    unitTests {
      // By default, local unit tests throw an exception any time the code you are testing tries to access
      // Android platform APIs (unless you mock Android dependencies yourself or with a testing
      // framework like Mockito). However, you can enable the following property so that the test
      // returns either null or zero when accessing platform APIs, rather than throwing an exception.
      returnDefaultValues true

      // Encapsulates options for controlling how Gradle executes local unit tests. For a list
      // of all the options you can specify, read Gradle's reference documentation.
      all {
        // Sets JVM argument(s) for the test JVM(s).
        jvmArgs '-XX:MaxPermSize=256m'

        // You can also check the task name to apply options to only the tests you specify.
        if (it.name == 'testDebugUnitTest') {
          systemProperty 'debug', 'true'
        }
      }
    }
  }
}

Mengoptimalkan build Anda

Bagian ini menyediakan beberapa konfigurasi untuk membantu mempercepat full dan incremental build.

Menciutkan kode Anda

Android Studio menggunakan ProGuard untuk menciutkan kode Anda. Untuk project baru, Android Studio menggunakan file setelan default (proguard-android.txt) dari tools/proguard/folder Android SDK. Untuk penciutan kode yang lebih maksimal, cobalah file proguard-android-optimize.txt yang terdapat di lokasi yang sama.

android {
  buildTypes {
    release {
      minifyEnabled true
      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
                                           'proguard-rules.pro'
    }
  }
  ...
}
...

Untuk menambahkan aturan ProGuard yang spesifik bagi setiap varian build, konfigurasikan properti proguardFiles tambahan untuk setiap ragam. Misalnya, contoh berikut menambahkan flavor2-rules.pro ke "flavor2". Sekarang versi rilis "flavor2" menggunakan ketiga aturan ProGuard karena mereka yang berasal dari blok rilis juga diterapkan.

android {
  ...
  buildTypes {
    release {
      minifyEnabled true
      proguardFiles getDefaultProguardFile('proguard-android.txt'),
             'proguard-rules.pro'
    }
  }
  productFlavors {
    flavor1 {
      ...
    }
    flavor2 {
      proguardFile 'flavor2-rules.pro'
    }
  }
}
...

Mengaktifkan penciutan kode dengan Instant Run

Untuk mengaktifkan penciutan kode dengan Instant Run, setel saja useProguard ke false (dan pertahankan setelan minifyEnabled ke true). Ini menggunakan penciut kode eksperimental yang tidak menyamarkan atau mengoptimalkan kode (jadi Anda sebaiknya mengaktifkan penciut ini hanya untuk tipe build "debug").

android {
  buildTypes {
    debug {
      minifyEnabled true
      useProguard false
      proguardFiles getDefaultProguardFile('proguard-android.txt'),
              'proguard-rules.pro'
    }
    release {
      minifyEnabled true
      proguardFiles getDefaultProguardFile('proguard-android.txt'),
              'proguard-rules.pro'
    }
  }
}

Mengonfigurasi opsi DEX

Gunakan properti berikut untuk memperbaiki waktu build ketika Gradle mengompilasi kode Anda ke dalam file DEX.

android {
  ...
  dexOptions {
    // Sets the maximum number of DEX processes
    // that can be started concurrently.
    maxProcessCount 8
    // Sets the maximum memory allocation pool size
    // for the dex operation.
    javaMaxHeapSize "2g"
    // Enables Gradle to pre-dex library dependencies.
    preDexLibraries true
  }
}

Memublikasikan Aplikasi Anda

Untuk mempelajari lebih lanjut tentang memublikasikan aplikasi ke Google Play, baca Memublikasikan Aplikasi Anda.

Menandatangani Aplikasi Anda

Meskipun Android Studio menyediakan cara mudah untuk mengonfigurasi penandatanganan versi rilis dari UI, Anda bisa secara manual mengonfigurasi blok signingConfigs di file build.gradle modul Anda:

android {
  ...
  defaultConfig { ... }

  // Encapsulates signing configurations.
  signingConfigs {
    // Creates a signing configuration called "release".
    release {
      // Specifies the path to your keystore file.
      storeFile file("my-release-key.jks")
      // Specifies the password for your keystore.
      storePassword "password"
      // Specifies the identifying name for your key.
      keyAlias "my-alias"
      // Specifies the password for your key.
      keyPassword "password"
    }
  }
  buildTypes {
    release {
      // Adds the "release" signing configuration to the release build type.
      signingConfig signingConfigs.release
      ...
    }
  }
}
...

Menghapus informasi penandatanganan pribadi dari project Anda

Secara default, penandatanganan konfigurasi dicatat dalam teks biasa ke file build.gradle modul. Bila Anda bekerja dengan tim atau project open-source, Anda bisa memindahkan informasi sensitif keluar dari file build dengan menjalankan langkah-langkah berikut.

  1. Buat file bernama keystore.properties dalam direktori akar project Anda dan sertakan informasi berikut:
    storePassword=myStorePassword
    keyPassword=myKeyPassword
    keyAlias=myKeyAlias
    storeFile=myStoreFileLocation
    
  2. Di file build.gradle Anda, muat file keystore.properties sebagai berikut (ini harus dilakukan sebelum blok android):
    // Creates a variable called keystorePropertiesFile, and initializes it to the
    // keystore.properties file.
    def keystorePropertiesFile = rootProject.file("keystore.properties")
    
    // Initializes a new Properties() object called keystoreProperties.
    def keystoreProperties = new Properties()
    
    // Loads the keystore.properties file into the keystoreProperties object.
    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
    
    android {
      ...
    }
    ...
    
  3. Masukkan informasi penandatanganan yang tersimpan di objek keystoreProperties:
    android {
      signingConfigs {
        config {
          keyAlias keystoreProperties['keyAlias']
          keyPassword keystoreProperties['keyPassword']
          storeFile file(keystoreProperties['storeFile'])
          storePassword keystoreProperties['storePassword']
        }
      }
      ...
    }
    ...
    
  4. Klik Sync Now di bilah notifikasi.

Untuk mempelajari lebih lanjut tentang penandatanganan aplikasi, baca Menandatangani Aplikasi Anda.

Menyederhanakan development aplikasi

Tips berikut membantu mempermudah development aplikasi Android Anda.

Berbagi kolom khusus dan nilai sumber daya dengan kode aplikasi Anda

Pada saat build, Gradle menghasilkan kelas BuildConfig sehingga kode aplikasi Anda bisa memeriksa informasi tentang build saat ini. Anda juga bisa menambahkan kolom khusus ke kelas BuildConfig dari file konfigurasi build Gradle menggunakan metode buildConfigField() dan mengakses nilai-nilai tersebut dalam kode waktu proses aplikasi. Demikian juga, Anda bisa menambahkan nilai sumber daya aplikasi dengan resValue().

android {
  ...
  buildTypes {
    release {
      // These values are defined only for the release build, which
      // is typically used for full builds and continuous builds.
      buildConfigField("String", "BUILD_TIME", "\"${minutesSinceEpoch}\"")
      resValue("string", "build_time", "${minutesSinceEpoch}")
      ...
    }
    debug {
      // Use static values for incremental builds to ensure that
      // resource files and BuildConfig aren't rebuilt with each run.
      // If they were dynamic, they would prevent certain benefits of
      // Instant Run as well as Gradle UP-TO-DATE checks.
      buildConfigField("String", "BUILD_TIME", "\"0\"")
      resValue("string", "build_time", "0")
    }
  }
}
...

Dalam kode aplikasi, Anda bisa mengakses properti dengan cara berikut:

...
Log.i(TAG, BuildConfig.BUILD_TIME);
Log.i(TAG, getString(R.string.build_time));

Berbagi properti dengan manifes

Dalam beberapa kasus, Anda mungkin perlu mendeklarasikan properti yang sama pada manifes dan kode Anda (misalnya saat mendeklarasikan otoritas untuk FileProvider). Daripada mengupdate properti yang sama pada beberapa lokasi untuk merefleksikan perubahan, tetapkan saja satu properti di file build.gradle modul agar tersedia untuk manifes dan kode Anda, seperti yang ditunjukkan pada contoh berikut. Untuk mempelajari lebih lanjut, baca Menyuntikkan Variabel Build ke dalam Manifes.

android {
  // For settings specific to a product flavor, configure these properties
  // for each flavor in the productFlavors block.
  defaultConfig {
    // Creates a property for the FileProvider authority.
    def filesAuthorityValue = applicationId + ".files"
    // Creates a placeholder property to use in the manifest.
    manifestPlaceholders =
      [filesAuthority: filesAuthorityValue]
      // Adds a new field for the authority to the BuildConfig class.
      buildConfigField("String",
                       "FILES_AUTHORITY",
                       "\"${filesAuthorityValue}\"")
  }
  ...
}
...

Dalam manifes Anda, akses placeholder dengan cara berikut:

<manifest>
  ...
  <application>
    ...
    <provider
      android:name="android.support.v4.content.FileProvider"
      android:authorities="${filesAuthority}"
      android:exported="false"
      android:grantUriPermissions="true">
      ...
    </provider>
  </application>
</manifest>

Berikut adalah tampilan mengakses kolom FILES_AUTHORITY di kode aplikasi Anda:

...
Uri contentUri = FileProvider.getUriForFile(getContext(),
  BuildConfig.FILES_AUTHORITY,
  myFile);
This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Ikuti Google Developers di WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (Dec 2017 Android Platform & Tools Survey)