I have an android library with flavors defined
flavorDimensions "player"
productFlavors {
educator {
dimension "player"
}
learner {
dimension "player"
}
}
and dependencies like so
dependencies {
learnerImplementation project(':learnerFeatureModule')
}
Now when I use this library in my Educator app, I get error
Project with path ':learnerFeatureModule' could not be found in project ':myLibrary'
because I have not defined :learnerFeatureModule in my settings.gradle.
I have defined missing strategy in Educator app/build.gralde too.
missingDimensionStrategy 'player', 'educator'
But learnerFeatureModule is learnerImplementation. Why is educator app even trying to resolve this?
I need a way, where Educator app does not look for this module as its not requried.
1 workaround that solves it for me (this does not use flavor as such)
in library build.gradle
dependencies {
def skipLearnerModule = rootProject.ext.get("skipLearnerModule")
if(!skipLearnerModule)
implementation project(':learnerFeatureModule')
and in educator app's root build.gradle
buildscript {
ext {
skipLearnerModule = true
}
I believe the reason why flavor does not work is because gradle's project configure step tries to resolve module for all variant of the app
In my android application, I have 2 library modules that need to be included conditionally based on flavor. Following is the application structure
:app:library1:library2
And app has 2 flavors, so it will generate 2 apk's, one free version and another paid. So accordingly configured app build.gradle as follows:
android {
flavorDimensions("billing_type")
productFlavors {
free {
dimension "billing_type"
}
paid {
dimension "billing_type"
}
}
}
dependencies {
implementation project(path: 'flavor1')
implementation project(path: 'flavor2')
}
As we can see, both library modules will be included in both flavors(free and paid). But i want to include library2 only in paid flavor. So how can i conditionally add library2 only in paid flavor? I followed some of the approaches mentioned in link
and made following changes:
android {
flavorDimensions("billing_type")
productFlavors {
free {
dimension "billing_type"
}
paid {
dimension "billing_type"
}
}
}
configurations {
freeImplementation
paidImplementation
}
dependencies {
freeImplementation implementation project(path: 'flavor1')
paidImplementation implementation project(path: 'flavor2')
}
All the references online are for older grdale versions which uses compile to add library modules,
But it has been deprecated since gradle plugin 3.0.0. So can anyone help me figure out how to conditionally add library module in particular flavor only in latest
For Gradle versions 3.0 and higher
When your main project uses modules or library modules(AAR) that have flavor dimensions, your app doesn't know which one to use. You should Use missingDimensionStrategy in the defaultConfig block of your app's build.gradle file to specify the default flavor. For example :
missingDimensionStrategy 'dimension', 'flavor1', 'flavor2'
Please check this link for more details.
I have a gradle project with a nested gradle project. How can I set a configuration on the root build.gradle and apply to all nested modules. The structure looks like:
project
build.gradle
settings.gradle
sub-project
build.gradle
inside settings.gradle, I includes the sub-project:
include ":sub-project"
in the root build.gradle, I have below settings:
android {
buildTypes {
staging {
initWith release
}
}
}
It works fine if I manually edit the build.gradle in sub-project. I wonder how I can pass this setting to the sub-project without updating its build.gradle
I tried to add below configuration on root build.gradle:
subprojects { pry ->
android {
buildTypes {
staging {
initWith release
}
}
}
}
but got this error:
Unable to find a matching configuration of project :sub-project:
- Configuration 'debugApiElements':
- Required com.android.build.api.attributes.BuildTypeAttr 'staging' and found incompatible value 'debug'.
Manually add the settings on the nested build.gradle works great but subprojects way doesn't work. What is the different between these two ways?
inside project/build.gradle, use the allprojects as below:
allprojects { prj ->
if (!project.hasProperty("android")) {
return
}
// this condition can be used to skip some project
if (prj.name == "<your-project-name-to-skip>"){
return
}
android {
...
productFlavors {
staging {
initWith release
}
}
...
}
}
If you want the particular settings applied to sub-projects only. Replace the allprojects with subprojects.
How do I use setIgnore on a local library either from the apps build.gradle or the library build.gradle based on the apps flavor. I am not sure if I can reference the apps build.gradle flavor/dimension from the library build.gradle. I also don't know if I can reference a library from the apps build.gradle and use lib.setIgnore(true). Any solution to solving this issue?
I am currently only using one dimension for the application and multiple flavors.
This is how it is typically done; but I need to set Ignore on a library based on the apps flavor.
android {
...
variantFilter { variant ->
if(variant.buildType.name == 'release' && variant.getFlavors().get(0).name == 'vanilla') {
variant.setIgnore(true)
}
}
}
Maybe you can use the library only when you need.
dependencies {
// use "mylib" for debug
debugImplementation project(path: ':mylib')
// all the flavors
implementation "com.android.support:appcompat-v7:28.0.0'
}
You can try to wait for the task graph to be assembled and then removes the undesired name pattern as follows:
gradle.taskGraph.whenReady { graph ->
graph.allTasks.findAll { it.name ==~ /.*vanilla.*/ }*.enabled = false
}
My app has several flavors for several markets in-app-billing systems.
I have a single library which shares the base code for all of my projects. So I decided to add those payment systems to this library as product flavors.
The question is can android library have product flavors?
If so, how can I include different flavors in respective flavor of the app?
I searched a lot, and I couldn't find anything about this scenario. The only close thing I found was this in http://tools.android.com/tech-docs/new-build-system/user-guide:
dependencies {
flavor1Compile project(path: ':lib1', configuration: 'flavor1Release')
flavor2Compile project(path: ':lib1', configuration: 'flavor2Release')
}
I changed configuration to different things but it did not work!
I'm using android studio 0.8.2.
Finally I found out how to do this, I will explain it here for others facing same problem:
If App and Library have same Flavor name(s)
It's possible since Gradle Plugin 3.0.0 (and later) to do something like:
Library build.gradle:
apply plugin: 'com.android.library'
// Change below's relative-path
// (as the `../` part is based on my project structure,
// and may not work for your project).
apply from: '../my-flavors.gradle'
dependencies {
// ...
}
android {
// ...
}
Project build.gradle:
buildscript {
// ...
}
apply plugin: 'com.android.application'
// Note that below can be put after `dependencies`
// (I just like to have all apply beside each other).
apply from: './my-flavors.gradle'
dependencies {
api project(':lib')
}
android {
productFlavors {
// Optionally, configure each flavor.
market1 {
applicationIdSuffix '.my-market1-id'
}
market2 {
applicationIdSuffix '.my-market2-id'
}
}
}
My flavors .gradle:
android {
flavorDimensions 'my-dimension'
productFlavors {
market1 {
dimension 'my-dimension'
}
market2 {
dimension 'my-dimension'
}
}
}
If App or Library has different Flavor-name (old answer)
The key part is to set publishNonDefault to true in library build.gradle, Then you must define dependencies as suggested by user guide.
Update 2022; publishNonDefault is now by default true, and setting it to false is ignored, since said option is deprecated.
The whole project would be like this:
Library build.gradle:
apply plugin: 'com.android.library'
android {
....
publishNonDefault true
productFlavors {
market1 {}
market2 {}
market3 {}
}
}
project build.gradle:
apply plugin: 'com.android.application'
android {
....
productFlavors {
market1 {}
market2 {}
market3 {}
}
}
dependencies {
....
market1Compile project(path: ':lib', configuration: 'market1Release')
market2Compile project(path: ':lib', configuration: 'market2Release')
// Or with debug-build type support.
android.buildTypes.each { type ->
market3Compile project(path: ':lib', configuration: "market3${type.name}")
}
}
Now you can select the app flavor and Build Variants panel and the library will be selected accordingly and all build and run will be done based on the selected flavor.
If you have multiple app module based on the library Android Studio will complain about Variant selection conflict, It's ok, just ignore it.
There are one problem with Ali answer. We are losing one very important dimension in our build variants. If we want to have all options (in my example below 4 (2 x 2)) we just have to add custom configurations in main module build.gradle file to be able to use all multi-flavor multi-buildType in Build Variants. We also have to set publishNonDefault true in the library module build.gradle file.
Example solution:
Lib build.gradle
android {
publishNonDefault true
buildTypes {
release {
}
debug {
}
}
productFlavors {
free {
}
paid {
}
}
}
App build.gradle
android {
buildTypes {
debug {
}
release {
}
}
productFlavors {
free {
}
paid {
}
}
}
configurations {
freeDebugCompile
paidDebugCompile
freeReleaseCompile
paidReleaseCompile
}
dependencies {
freeDebugCompile project(path: ':lib', configuration: 'freeDebug')
paidDebugCompile project(path: ':lib', configuration: 'paidDebug')
freeReleaseCompile project(path: ':lib', configuration: 'freeRelease')
paidReleaseCompile project(path: ':lib', configuration: 'paidRelease')
}
Update for Android Plugin 3.0.0 and higher
According to the official Android Documentation - Migrate dependency configurations for local modules,
With variant-aware dependency resolution, you no longer need to use variant-specific configurations, such as freeDebugImplementation, for local module dependencies—the plugin takes care of this for you
You should instead configure your dependencies as follows:
dependencies {
// This is the old method and no longer works for local
// library modules:
// debugImplementation project(path: ':library', configuration: 'debug')
// releaseImplementation project(path: ':library', configuration: 'release')
// Instead, simply use the following to take advantage of
// variant-aware dependency resolution. You can learn more about
// the 'implementation' configuration in the section about
// new dependency configurations.
implementation project(':library')
// You can, however, keep using variant-specific configurations when
// targeting external dependencies. The following line adds 'app-magic'
// as a dependency to only the "debug" version of your module.
debugImplementation 'com.example.android:app-magic:12.3'
}
So in Ali's answer, change
dependencies {
....
market1Compile project(path: ':lib', configuration: 'market1Release')
market2Compile project(path: ':lib', configuration: 'market2Release')
}
to
implementation project(':lib')
And plugin will take care of variant specific configurations automatically. Hope it helps to others upgrading Android Studio Plugin to 3.0.0 and higher.
My Android Plugin is 3.4.0,and I find that it doesn't need configurations now.All you need is to make sure the flavorDimensions and productFlavors in application contains one productFlavor of the same flavorDimensions and productFlavors in libraries.For sample:
In mylibrary's build.gradle
apply plugin: 'com.android.library'
android {
....
flavorDimensions "mylibFlavor"
productFlavors {
market1
market2
}
}
application's build.gradle:
apply plugin: 'com.android.application'
android {
....
flavorDimensions "mylibFlavor", "appFlavor"
productFlavors {
market1 {
dimension "mylibFlavor"
}
market2 {
dimension "mylibFlavor"
}
common1 {
dimension "appFlavor"
}
common2 {
dimension "appFlavor"
}
}
}
dependencies {
....
implementation project(path: ':mylibrary')
}
After sync,you can switch all options in Build Variants Window:
To get the flavors working on an AAR library, you need to define defaultPublishConfig in the build.gradle file of your Android Library module.
For more information, see: Library Publication.
Library Publication
By default a library only publishes its release variant. This variant
will be used by all projects referencing the library, no matter which
variant they build themselves. This is a temporary limitation due to
Gradle limitations that we are working towards removing. You can
control which variant gets published:
android {
defaultPublishConfig "debug" }
Note that this publishing configuration name references the full
variant name. Release and debug are only applicable when there are no
flavors. If you wanted to change the default published variant while
using flavors, you would write:
android {
defaultPublishConfig "flavor1Debug" }
I also ran into a problem compiling modules for various options.
What i've found:
It looks like we don't need add publishNonDefault true into lib's build.gradle file, since Gradle 3.0.1.
After decompiling a class BaseExtension found this:
public void setPublishNonDefault(boolean publishNonDefault) {
this.logger.warn("publishNonDefault is deprecated and has no effect anymore. All variants are now published.");
}
And instead of:
dependencies {
...
Compile project(path: ':lib', configuration: 'config1Debug')
}
We should use:
dependencies {
...
implementation project(':lib')
}
Only the important thing, is to add a configurations {...} part to the build.gradle.
So, the final variant of app's build.gradle file is:
buildTypes {
debug {
...
}
release {
...
}
}
flavorDimensions "productType", "serverType"
productFlavors {
Free {
dimension "productType"
...
}
Paid {
dimension "productType"
...
}
Test {
dimension "serverType"
...
}
Prod {
dimension "serverType"
...
}
}
configurations {
FreeTestDebug
FreeTestRelease
FreeProdDebug
FreeProdRelease
PaidTestDebug
PaidTestRelease
PaidProdDebug
PaidProdRelease
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation project(':lib')
...
}
Also, you can use Filter variants to restrict build variants.
P.s. don't forget to include modules in the settings.gradle file, like:
include ':app'
include ':lib'
project(':lib').projectDir = new File('app/libs/lib')
At the moment it's not possible, although if I recall correctly its a feature they want to add. (Edit 2: link, link2 )
Edit:
For the moment I'm using the defaultPublishConfig option to declare which library variant get's published:
android {
defaultPublishConfig fullRelease
defaultPublishConfig demoRelease
}
I know this subject has been closed, but just an update with gradle 3.0, see this : https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration.html#variant_aware and grep matchingFallbacks and missingDimensionStrategy.
Now it's way more simple to declare the dependencies between module flavors.
...and in this precise case with gradle3.0, as flavors share the same name, gradle would map them magically, there is no configuration required.
In this situation. How could I import the dependency for a specific build. For example: market1Common1Debug
market1Common1DebugImplementation 'androidx.appcompat:1.2.0'