BuildConfig.DEBUG always false when building library projects with gradle
AndroidGradleAndroid LibraryAndroid Problem Overview
BuildConfig.DEBUG is not working (= logically set to false) when I run my app in debug mode. I use Gradle to build. I have a library project where I do this check. BuildConfig.java looks like this in the build debug folder:
/** Automatically generated the file. DO NOT MODIFY */
package common.myProject;
public final class BuildConfig {
public static final boolean DEBUG = Boolean.parseBoolean("true");
}
and in the release folder:
public static final boolean DEBUG = false;
both in the library project and in the application project.
I tried to get around this by checking a variable which is set a class of my project. This class inherits from the library and starts on startup.
<application
android:name=".MyPrj" ...
This leads to another problem: is that I use my DEBUG variable in a DataBaseProvider which runs before the application class, and it will not run properly due to this bug.
Android Solutions
Solution 1 - Android
With Android Studio 1.1 and having also the gradle version at 1.1 it is possible:
Library
android {
publishNonDefault true
}
App
dependencies {
releaseCompile project(path: ':library', configuration: 'release')
debugCompile project(path: ':library', configuration: 'debug')
}
Complete documentation can be found here http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Library-Publication
EDIT:
The issue has just been marked as fixed for the Android Studio Gradle Version 3.0. There you can just use implementation project(path: ':library')
and it'll select the correct configuration automatically.
Solution 2 - Android
This is expected behavior for this.
Library projects only publish their release variants for consumption by other projects or modules.
We're working at fixing this but this is non trivial and requires a significant amount of work.
You can track the issue at https://code.google.com/p/android/issues/detail?id=52962
Solution 3 - Android
Check for imports
, sometimes BuildConfig is imported from any class of library unintentionally.
For example:
import io.fabric.sdk.android.BuildConfig;
In this case BuildConfig.DEBUG will always return false;
import com.yourpackagename.BuildConfig;
In this case BuildConfig.DEBUG will return your real build variant.
Solution 4 - Android
This is like Phil's answer except it doesn't need the context:
private static Boolean sDebug;
/**
* Is {@link BuildConfig#DEBUG} still broken for library projects? If so, use this.</p>
*
* See: https://code.google.com/p/android/issues/detail?id=52962</p>
*
* @return {@code true} if this is a debug build, {@code false} if it is a production build.
*/
public static boolean isDebugBuild() {
if (sDebug == null) {
try {
final Class<?> activityThread = Class.forName("android.app.ActivityThread");
final Method currentPackage = activityThread.getMethod("currentPackageName");
final String packageName = (String) currentPackage.invoke(null, (Object[]) null);
final Class<?> buildConfig = Class.forName(packageName + ".BuildConfig");
final Field DEBUG = buildConfig.getField("DEBUG");
DEBUG.setAccessible(true);
sDebug = DEBUG.getBoolean(null);
} catch (final Throwable t) {
final String message = t.getMessage();
if (message != null && message.contains("BuildConfig")) {
// Proguard obfuscated build. Most likely a production build.
sDebug = false;
} else {
sDebug = BuildConfig.DEBUG;
}
}
}
return sDebug;
}
Solution 5 - Android
As a workaround, you can use this method, which uses reflection to get the field value from the app (not the library):
/**
* Gets a field from the project's BuildConfig. This is useful when, for example, flavors
* are used at the project level to set custom fields.
* @param context Used to find the correct file
* @param fieldName The name of the field-to-access
* @return The value of the field, or {@code null} if the field is not found.
*/
public static Object getBuildConfigValue(Context context, String fieldName) {
try {
Class<?> clazz = Class.forName(context.getPackageName() + ".BuildConfig");
Field field = clazz.getField(fieldName);
return field.get(null);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
To get the DEBUG
field, for example, just call this from your Activity
:
boolean debug = (Boolean) getBuildConfigValue(this, "DEBUG");
I have also shared this solution on the AOSP Issue Tracker.
Solution 6 - Android
Not really the correct way to check if you are in debug flavor, but you can check if the app itself is debuggable via:
private static Boolean sIsDebuggable;
public static boolean isDebuggable(Context context) {
if (sIsDebuggable == null)
sIsDebuggable = (context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
return sIsDebuggable;
}
The default behavior of apps and libraries will match it perfectly.
If you need a better workaround, you can use this instead:
public static boolean isInDebugFlavour(Context context) {
if (sDebugFlavour == null) {
try {
final String packageName = context.getPackageName();
final Class<?> buildConfig = Class.forName(packageName + ".BuildConfig");
final Field DEBUG = buildConfig.getField("DEBUG");
DEBUG.setAccessible(true);
sDebugFlavour = DEBUG.getBoolean(null);
} catch (final Throwable t) {
sDebugFlavour = false;
}
}
return sDebugFlavour;
}
Solution 7 - Android
You can create your own BuildConfig class for each build type using gradle
public class MyBuildConfig
{
public static final boolean DEBUG = true;
}
for /src/debug/.../MyBuildConfig.java and...
public class MyBuildConfig
{
public static final boolean DEBUG = false;
}
for /src/release/.../MyBuildConfig.java
Then use:
if (MyBuildConfig.DEBUG)
Log.d(TAG, "Hey! This is debug version!");
Solution 8 - Android
Here is another solution.
-
Create an interface
public interface BuildVariantDetector {
boolean isDebugVariant();
}
-
Use this interface on Application class (Appplication module)
public class MyApplication extends Application implements BuildVariantDetector {
@Override public boolean isDebugVariant() { return BuildConfig.DEBUG; //application (main module) Buildonfig }
}
And then in library module:
boolean debugVariant = ((BuildVariantDetector)getApplication()).isDebugVariant();
Solution 9 - Android
We had the same problem. I came up with something like this:
We have a SDK (library) and a demo project, hierarchy looks like this:
Parent
|
+ SDK (:SDK)
|
+ DemoApp (:DemoApp)
For the demo app we have, were :SDK:jarjarDebug
and :SDK:jarjarRelease
are some specific tasks for :SDK
that produce some post-processed jars:
dependencies {
debugCompile tasks.getByPath(":SDK:jarjarDebug").outputs.files
releaseCompile tasks.getByPath(":SDK:jarjarRelease").outputs.files
... more dependencies ...
}
This works even for multiple buildTypes
built at once. Debugging is a bit difficult though. Please comment.
Solution 10 - Android
In my case I was importing the wrong BuildConfig
as my project has many library modules. The fix was to import the correct BuildConfig
for my app
module.
Solution 11 - Android
This is my workaround: reflect BuildConfig of app module:
`public static boolean debug = isDebug();
private static boolean isDebug() {
boolean result = false;
try {
Class c = Class.forName("com.example.app.BuildConfig");
Field f = c.getField("DEBUG");
f.setAccessible(true);
result = f.getBoolean(c);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return result;
}`
Solution 12 - Android
You could try this on each of the projects buildTypes:
parent.allprojects.each{ project -> android.defaultConfig.debuggable = true}
Solution 13 - Android
Working with debuggable true in gradle file.
buildTypes {
demo{
debuggable true
}
live{
debuggable true
}
}
Solution 14 - Android
BuildConfig.DEBUG is not reliable at all, Android has provided an internal flag that is globally available indicating if a build is in Debug or non-Debug mode
(getContext().getApplicationInfo().flags &ApplicationInfo.FLAG_DEBUGGABLE) != 0)
will be true if it is in debug
Credits : https://medium.com/@elye.project/checking-debug-build-the-right-way-d12da1098120