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?

Averroes

the real question is: why isn't this built in to the android gradle plugin?!?!?!?! – Tamaru

@Armand: maybe because local.properties is in use for Android Studio's own local config, and having another file of the same name might create a little bit of confusion. See https://mcmap.net/q/81282/-how-do-i-read-properties-defined-in-local-properties-in-build-gradle below – Refection

@Tamaru it's a pity this was not built in 5 years ago, but later this was added: android.getSdkDirectory() simply works. – Sporades

Related post: Sign APK without putting keystore info in build.gradle – Vanderbilt

Does this answer your question? Gradle - Include Properties File – Vanderbilt

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.

Haberdashery

What it is "project.rootProject"? – Profiteer

Added a brief explanation – Haberdashery

What do you mean with project? My ide is giving me an error. How do I get project path. – Profiteer

Inside a build.gradle file project is a variabile which refers to the current project. If you have strange errors ask a new question. – Haberdashery

If I copy your code inside a utility class in app/src/main/java/my_package_name/Utils.java it cannot be resolved. How can I read local.properties from a Utility class? – Profiteer

As I said it would be better if you ask your own question. BTW you should read the local.properties file in the build.gradle and generate one or more BuildConfig fields. #17198136 – Haberdashery

I want to write a library that reads custom values declared in a property file by the user of the library. These values are different depending on who is using the library. It's the first time I'm facing this situation and I'm trying to figure out how to do that... – Profiteer

What if I don't know the latest version of sdkdir build-tools, and I want gradle to handle it for me? For example, finding sdk.ri/build-tools/24.0.0/ – Louralourdes

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);

Style

This is the correct answer. How is it not selected? The chosen answer doesn't even provide a solution?? – Mongolic

Cannot resolve symbol 'Properties' in my case – Low

OK, could I put Properties declaration in defaultConfig? Why do people put it outside of defaultConfig scope? – Merrill

If I try to access this variable in manifest file, it won't build (says resource not found) – Incensory

Caused by: groovy.lang.MissingMethodException: No signature of method: java.util.HashMap.load() is applicable for argument types: (DataInputStream) values: [java.io.DataInputStream@3e893459] Possible solutions: clear(), clear(), clone(), sort(), find(), find(groovy.lang.Closure) – Sec

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

Raddie

This works and easy without need context for getString() – Grubstake

Thanks a lot ! after a lot of hussle this worked – Rime

I am not able to access sdk_dir using BuildConfig – Columbic

This is not working at all – Columbic

This do work till now. I have just implement a map sample and find that it seems to be a part of google map support from google. Thanks a lot Sattar. The classpath line would look like id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin' version '2.0.1' apply false on newer android studio – Agatha

It wasn't working for me until I "Rebuild Project" – Commingle

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.

Institutionalize

For Gradle 1.1.0 you nee to use plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder() as can be seen here: #28615939 – Pichardo

Broken again with the shift to "experimental" plugin :( – Sporades

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);

Selenodont

How does this work with versioning systems? You would not want to create commits and pull requests everytime that you wanted to change a property – Lazar

In the same way you use the other method – Selenodont

What other method? Would this resolve the values during build without touching the source code? – Lazar

The real question is: is local.properties is included in your repository? If so, does it really have to be? If still yes, you will need to version any changes to your properties file. – Selenodont

No. It is not, as it should be. I saw a method (which I can't find) that loads properties from an external properties file and adds them to buildConfigField, which end up in BuildConfig.java as static final fields. I thought that was quicker than dealing with XML reading etc. – Lazar

Answer 6

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

Vanderbilt

Answer 7

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).

Belize

Answer 8

I think it's more elegant way.

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

it works on android gradle 1.5.0 .

Mccormack

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"))
      }
   }
}

Codie

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

Larcener