Ramya K Sharma
Ramya K Sharma

Reputation: 743

Android Studio - Build variation & Module selection

I'm building an application which needs a library with 2 variants - simulator & actual.

My objective is to create build tasks say assembleSimulatorDebug & assembleDebug. assembleSimulatorDebug will include simulator module/library and assembleDebug will include actual module to build the apk.

I'm thinking of having if else blocks in dependencies sections of build.gradle. Can I have something like this?

I'm very new to gradle and trying from yesterday to set up something like this. It will be v helpful if anyone can provide some hints or links where I can get an idea to achieve this.

Upvotes: 1

Views: 3381

Answers (2)

gio
gio

Reputation: 5020

Found solution for 2 libraries, it looks simpler. It's based on next from official guide

Finally, like Build Types, Product Flavors can have their own dependencies. For instance, if the flavors are used to generate a ads-based app and a paid app, one of the flavors could have a dependency on an Ads SDK, while the other does not.

dependencies {
flavor1Compile "..."
}

So you can create 2 individual libraries and create 2 flavors, for example, libraries are library-normal and library-simulator and flavors are normal and simulator.

Application build.gradle

apply plugin: 'com.android.application'

android {
    lintOptions {
        abortOnError false
    }
    compileSdkVersion 21
    buildToolsVersion "21.1.1"

    defaultConfig {
        applicationId "com.tivogi.gradle"
        minSdkVersion 15
        targetSdkVersion 21
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    productFlavors {
        normal {
        }
        simulator {
        }
    }

}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'
    normalCompile project(":library-normal")
    simulatorCompile project(":library-simulator")
}

Application:

  • add only those lines into dependencies;

    normalCompile project(":library-normal")
    simulatorCompile project(":library-simulator")
    

Library:

  • does not require any change;

I published sample project of this solution at individual-libraries branch.

Upvotes: 2

gio
gio

Reputation: 5020

Update: Found another solution. It's in another my answer.

It is possible by usage of 'Flavor products' of android gradle plugin. You can split library implementation by product flavor.

Initial requirements 'com.android.tools.build:gradle:1.0.0', Android Studio 1.0.1.

I created project at GitHub, so you'll be able to get it, run and learn.

You need to create two flavors of your app and library, too. For example, normal and simulator

Application's build.gradle

apply plugin: 'com.android.application'

android {
    lintOptions {
        abortOnError false
    }
    compileSdkVersion 21
    buildToolsVersion "21.1.1"

    defaultConfig {
        applicationId "com.tivogi.gradle"
        minSdkVersion 15
        targetSdkVersion 21
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    productFlavors {
        normal {
        }
        simulator {
        }
    }

}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'
    normalCompile project(path: ':library', configuration: 'normalRelease')
    simulatorCompile project(path: ':library', configuration: 'simulatorRelease')
}

Library's build.gradle

apply plugin: 'com.android.library'

android {
    publishNonDefault true

    compileSdkVersion 21
    buildToolsVersion "21.1.1"

    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 21
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    productFlavors {
        normal {
        }
        simulator {
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'
}

Library:

  • split implementation between flavors by productFlavors (see my sample project if will have questions about that);
  • add publishNonDefault true into its build.gradle

    From Gradle Plugin User Guide

    It is also possible to publish all variants of a library. We are planning to allow this while using a normal project-to-project dependency (like shown above), but this is not possible right now due to limitations in Gradle (we are working toward fixing those as well). Publishing of all variants are not enabled by default. To enable them:

    android {
    publishNonDefault true
    }

Application:

  • add normal and simulator product flavors (productFlavors);
  • add next lines to dependencies section

    normalCompile project(path: ':library', configuration: 'normalRelease')
    simulatorCompile project(path: ':library', configuration: 'simulatorRelease')
    

    From Gradle Plugin User Guide

    To create a dependency on another published artifact, you need to specify which one to use:

    dependencies {
    flavor1Compile project(path: ':lib1', configuration: 'flavor1Release')
    flavor2Compile project(path: ':lib1', configuration: 'flavor2Release')
    }

After all of that you'll be able to build 2 variants of applicaiton: normal and simulator.

Upvotes: 3

Related Questions