Hands on the Gradle

Introduction to the Gradle build system and the community driven Android plugin. For DroidCon Berlin 2011 barcamp.

Transcript

1. S
   Hands on the Gradle
   Painless Android builds
   © 2011 Matthias Käppler
   Qype GmbH
   

   View Slide

2. What is Gradle?
   S  Gradle is a task based build system. From files and
   configuration it assembles build artifacts.
   S  Gradle is flexible. It is not bound to any specific process or
   technology.
   S  Gradle uses a Groovy based DSL to write configuration.
   This makes it easy to read and write Gradle scripts.
   

   View Slide

3. The Gradle manifesto
   S  „Build scripts are code.“
   S  Don‘t expect, allow.
   S  Don‘t re-invent, re-use.
   S  Don‘t inherit, inject.
   S  Scale to the complexity of a problem.
   – „Make the impossible possible, the possible easy, and the
   easy elegant.“
   

   View Slide

4. Gradle vs. Maven
   

   

   

   maven-antrun-plugin

   

   

   install

   

   run

   

   

   

   

   

   

   

   

   

   

   
   

   View Slide

5. Gradle vs. Maven (cont.)
   println "dunno, must be a Maven thing."
   

   View Slide

6. Gradle vs. Maven (cont.)
   S  Maven is declarative.
   Gradle is imperative.
   S  Maven is verbose.
   Gradle is concise.
   S  Maven assumes Maven.
   Gradle doesn‘t.
   S  Maven scales poorly to simple problems.
   Gradle scales with the complexity of a problem.
   

   View Slide

7. Gradle vs. Maven (cont.)
   S  Maven has a rich plug-in ecosystem.
   Gradle still needs to catch-up here.
   S  Maven has very good IDE support.
   Gradle has... IDE support.
   S  Maven has project archetypes.
   Gradle doesn‘t.
   

   View Slide

8. How is Gradle used?
   $ls

   build/ build.gradle ...
   ...
   $gradle tasks
   $gradle clean build
   $gradle androidInstall androidInstrument
   

   View Slide

9. build.gradle
   env = System.getenv()
   dependsOnChildren()
   apply from: ‘shared.gradle'
   allprojects {

   apply plugin: 'java'

   }
   task hello << {

   println ‘hello from Gradle‘

   }
   

   View Slide

10. Demo
    Move along, nothing to see here.
    

    View Slide

11. More about tasks
    S  There are different ways how tasks can be used or exposed
    in a build script:
    1 – by writing them
    2 – through project.ant
    3 – by applying a plug-in
    

    View Slide

12. Writing tasks
    task hello << {

    4.times { println ‘hello from Gradle‘ }

    }

    

    hello.dependsOn initLang

    

    hello.someProperty = 1
    

    View Slide

13. Writing tasks (cont.)
    project.task(‘hello‘, dependsOn: ‘initLang‘)

    

    greeter = { println it }

    

    hello.doLast greeter.curry(‘hello from Gradle‘)
    

    View Slide

14. Ant tasks
    S  Ant tasks are first class citizens in Gradle. You access them
    through Groovy‘s AntBuilder DSL.
    

    myProp = ant.properties["my.prop"]

    

    ant.copy {

    from zipTree("/path/to/lib.jar")

    into "$buildDir/extracted-classes"

    exclude "com.example/**"

    }
    

    View Slide

15. Plug-ins
    S  Most of Gradle‘s functionality comes from plug-ins. This helps in
    keeping the core Gradle APIs lean and clean.
    

    apply plugin: 'java'

    apply plugin: 'maven'

    

    ...

    

    $gradle clean install
    

    View Slide

16. Plug-ins (cont.)
    S  Writing Gradle plug-ins is very simple. Check this out.
    

    class MyPlugin implements Plugin {

    def apply(Project project) {

    project.task(‘hello‘) << {

    println ‘hello, people‘

    }

    }

    }
    

    View Slide

17. Dependencies
    S  Gradle doesn‘t define ist own dependency management system.
    Instead, it builds on Apache Ivy.
    

    repositories {

    mavenCentral()

    mavenRepo urls: "http://my.repo.com"

    flatDir dirs: "libs"

    }
    

    View Slide

18. Dependencies (cont.)
    S  Dependencies are grouped into configurations. A configuration is
    simply a set of files bound to a name.
    

    dependencies {

    compile "commons-lang:commons-lang:2.5"

    compile fileTree(dir: "libs", include: "*.jar")

    testCompile "junit:junit:4.8.2"

    }
    

    View Slide

19. Android
    S  There‘s a Gradle plug-in for Android.
    

    https://github.com/jvoegele/gradle-android-plugin
    

    View Slide

20. Setting it up
    S  Now:

    

    buildscript {

    

    repositories {

    mavenRepo(urls: 'http://jvoegele.com/maven2/‘)

    }

    

    dependencies {

    classpath 'com.jvoegele.gradle.plugins:android-plugin:0.9.8‘

    }

    }

    

    apply plugin: com.jvoegele.gradle.plugins.android.AndroidPlugin
    S  Soon:

    

    apply plugin: 'android'
    

    View Slide

21. What‘s in store
    S  The plug-in adds the following tasks:
    S  :androidProcessResources
    S  :androidPackage
    S  :androidInstall
    S  :androidInstrument
    S  [:proguard]
    

    

    $gradle clean andInstall :test-proj:andInstr
    

    View Slide

22. Instrumentation tests
    androidInstrument {

    

    runners {

    

    run testpackage: "unit", with: "com.my.UnitTestRunner",
    name: "instrumentation-unit-tests"

    

    run annotation: "android.test.suitebuilder.annotation.Smoke"

    

    run with: "com.my.OtherTestRunner”, options: "…”

    

    }

    

    }
    

    View Slide

23. Thanks
    Thanks for listening!
    

    View Slide

24. Android in Practice
    Charlie Collins, Michael Galpin, Matthias Käppler
    •  Real world practical recipes
    •  Focus on intermediate to professional developers
    •  Two chapters on testing and build automation
    Summer 2011
    MEAP edition available
    http://manning.com/collins
    

    View Slide