How do I read properties defined in local.properties in build.gradle

Question

I have set sdk.dir and ndk.dir in local.properties.

How do I read the values of sdk.dir and ndk.dir in the build.gradle file?

Answer 1

You can do that in this way:

Properties properties = new Properties()
properties.load(project.rootProject.file('local.properties').newDataInputStream())
def sdkDir = properties.getProperty('sdk.dir')
def ndkDir = properties.getProperty('ndk.dir')

Use project.rootProject if you are reading the properties file in a sub-project build.gradle:

.
├── app
│   ├── build.gradle <-- You are reading the local.properties in this gradle build file
│   └── src
├── build.gradle
├── gradle
├── gradlew
├── gradlew.bat
├── settings.gradle
└── local.properties

In case the properties file is in the same sub-project directory you can use just project.

Answer 2

local.properties

default.account.iccid=123

build.gradle -

def Properties properties = new Properties()
properties.load(project.rootProject.file("local.properties").newDataInputStream())

defaultConfig {

    resValue "string", "default_account_iccid", properties.getProperty("default.account.iccid", "")
}

and in code you get it as other string from Resources -

resources.getString(R.string.default_account_iccid);

Answer 3

now it's more simple with the new google plugin

1- add your property

sdk_dir="sdk dir"

2- add the plugin (Groovy) this in top-level (project level)

buildscript {
 dependencies {
     classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:1.3.0"
 }
}

and in your app Gradle

plugins {
    id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'
}

3- build your project 4- access it like this

BuildConfig.sdk_dir

Answer 4

Although @rciovati's answer is certainly correct, there is also an alternative way of reading the values for sdk.dir and ndk.dir.

As pointed out in this blog entry by Gaku Ueda (Getting ndk directory) the BasePlugin class offers methods for getNdkFolder() and getSdkFolder():

def ndkDir = project.plugins.findPlugin('com.android.application').getNdkFolder()
def sdkDir = project.plugins.findPlugin('com.android.application').getSdkFolder()

Note: You may have to change com.android.applicationto com.android.libraryif you are building a library

This is maybe a more elegant way of reading the folder values. Although it has to be said that the answer provided by @rciovati is more flexible, as one could read any value in the properties file.

Answer 5

Adding the property

The following Gradle technique shows you how to store a property in your local.properties file so that it can be securely referenced by your app.

1. Open the local.properties in your project level directory, and then add your property like the following example:

sdk.dir=MY_SDK_DIR

2. In your app-level build.gradle file, add this code in the defaultConfig element. This allows Android Studio to read the sdk.dir property from the local.properties file at build time and then inject the build variable into your res/gradleResVlues.xml.

Properties properties = new Properties()
if (rootProject.file("local.properties").exists()) {
    properties.load(rootProject.file("local.properties").newDataInputStream())
}

resValue "string", "sdk_dir", properties.getProperty("sdk.dir", "")

3. Save the files and sync your project with Gradle.
4. Retrive your string using the following code

getString(R.string.sdk_dir);

Answer 6

The answer that loads local.properties manually above obviously works, and the next one that requires you to know which plugin was applied should work as well.

These approaches might be a little better for some since they are more generic because they work regardless of whether you're using the Application, Test, or Library plugin. These snippets also give you full programmatic access to all of the Android plugin config (Product Flavors, Build Tools version, and much more):

If you need access in a build.gradle file that is using the Android Gradle Plugin simply access the Android DSL directly as it's now available directly:

project.android.sdkDirectory

The longer form (below) of this is handy if you're creating custom Gradle Tasks classes or Plugins or simply want to view which properties are available.

// def is preferred to prevent having to add a build dependency.
def androidPluginExtension = project.getExtensions().getByName("android");

// List available properties.
androidPluginExtension.properties.each { Object key, Object value ->
    logger.info("Extension prop: ${key} ${value}")
}
String sdkDir = androidPluginExtension.getProperties().get("sdkDirectory");
System.out.println("Using sdk dir: ${sdkDir}");

At the time of this posting there is also a handy adbExe property that is definitely worth noting.

This code has to execute AFTER the Android Gradle Plugin is configured per the Gradle livecycle. Typically this means you put it in the execute method of a Task or place it AFTER the android DSL declaration in an Android app/libraries' build.gradle file).

These snippets also come with the caveat that as you upgrade Android Gradle Plugin versions these properties can change as the plugin is developed so simply test when moving between versions of the Gradle and Android Gradle plugin as well as Android Studio (sometimes a new version of Android Studio requires a new version of the Android Gradle Plugin).

Answer 7

This is for Kotlin DSL (build.gradle.kts):

import java.util.*
// ...

val properties = Properties().apply {
    load(rootProject.file("local.properties").reader())
}
val myProp = properties["propName"]

In Android projects (where you have applied the android plugin) you can also do this:

import com.android.build.gradle.internal.cxx.configure.gradleLocalProperties
// ...

val properties = gradleLocalProperties(rootDir)
val myProp = properties["propName"]

Answer 8

I think it's more elegant way.

println "${android.getSdkDirectory().getAbsolutePath()}"

it works on android gradle 1.5.0 .

Answer 9

in kotlin dsl :

build.gradle file

val properties = Properties()
properties.load(project.rootProject.file("local.properties").reader())
...
android{
   buildTypes {


    debug {
        buildConfigField("String", "SOMETHING", properties.getProperty("something"))
      }
   }
}

Answer 10

build.gradle (:app)

sourceSets {
    main {
        resources {
            srcDirs = ["src/main/resources"]
        }
    }
}

app/src/main/resources/yourfile.properties

test_feature=test-of-feature

YourClass.kt

fun getProperty(key: String): String? {
    val properties = Properties()
    val propertiesFile = Thread.currentThread().contextClassLoader.getResourceAsStream("yourfile.properties")
    properties.load(propertiesFile)
    return properties.getProperty(key)
}

getProperty("test_feature")

GL