This document discusses using Groovy on Android. It provides an overview of Groovy including its syntax features like closures, GStrings, maps/lists, and operators. It also discusses Groovy's advantages like simplifying testing and seamlessly integrating with Java. The document demonstrates various Groovy features and gives examples of working with I/O. It briefly mentions AST transformations in Groovy and the SwissKnife library for injecting views and handling threading. The document concludes with recommending some Groovy literature and thanking the audience.

1. Groovy on Android
Pascal Nsue Engonga
2015

2. Agenda
● What is Groovy?
● Syntax(Closure. Array/Map. GString and
other features).
● Pros and cons of using Groovy.
● AST.
● SwissKnife.

3. Joke #0
When Android developers get java 8?

4. What is the Groovy?
● Is an agile and dynamic language for the Java Virtual Machine
● Builds upon the strengths of Java but has additional power features inspired by languages like Python,
Ruby and Smalltalk
● Makes modern programming features available to Java developers with almost-zero learning curve
● Provides the ability to statically type check and statically compile your code for robustness and
performance
● Supports Domain-Specific Languages and other compact syntax so your code becomes easy to read
and maintain
● Makes writing shell and build scripts easy with its powerful processing primitives
● Simplifies testing by supporting unit testing and mocking out-of-the-box
● Seamlessly integrates with all existing Java classes and libraries
● Compiles straight to Java bytecode so you can use it anywhere you can use Java

5. Usage

6. Polling

7. Keywords
as assert break case
catch class const continue
def default do else
enum extends false finally
for goto if implements
import in instanceof interface
new null package return
super switch this throw
throws trait true try
while

8. Groovy Features

9. Joke #1

10. Closure
Closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and
be assigned to a variable.
● { item++ }
● { -> item++ }
● { println it }
● { it -> println it }
● { name -> println name }
● { String x, int y ->
println "hey ${x} the value is ${y}"
}
● { reader ->
def line = reader.readLine()
line.trim()
}

11. GString
//Now you can ref to a variable in string
def name = 'Guillaume' // a plain string
def greeting = "Hello $name"
assert greeting.toString() == 'Hello Guillaume'
//Or even do some operations
def sum = "The sum of 2 and 3 equals ${2 + 3}"
assert sum.toString() == 'The sum of 2 and 3 equals 5'

12. Map/List
def list = [5, 6, 7, 8]
assert list.get(2) == 7
assert list[2] == 7
def map = [name: 'Gromit', likes: 'cheese', id: 1234]
def emptyMap = [:]
assert map.get('name') == 'Gromit'
assert map.get('id') == 1234
assert map['name'] == 'Gromit'
assert map['id'] == 1234

13. Range
def range = 5..8
assert range.size() == 4
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
// lets use a half-open range
range = 5..<8
assert range.from == 5
assert range.to == 8

14. Safe navigation & Elvis operator
def person = Person.find { it.id == 123 }
def firstChar = person?.name?.charAt(0)
assert name == null
displayName = user.name ? user.name : 'Anonymous'
displayName = user.name ?: 'Anonymous'

15. Spread operator
class Car {
String make
String model
}
def cars = [
new Car(make: 'Peugeot', model: '508'),
new Car(make: 'Renault', model: 'Clio')]
def makes = cars*.make
assert makes == ['Peugeot', 'Renault']

16. Regular expression operators
//has it’s own literal
def p = ~/foo/
assert p instanceof Pattern
//Example
def text = "some text to match"
def m = text =~ /match/
assert m instanceof Matcher
if (!m) {
throw new RuntimeException("Oops, text not found!")
}

17. Method pointer operator
def transform(List elements, Closure action) {
def result = []
elements.each {
result << action(it)
}
result
}
String describe(Person p) {
"$p.name is $p.age"
}
def action = this.&describe
def list = [
new Person(name: 'Bob', age: 42),
new Person(name: 'Julia', age: 35)]
assert transform(list, action) == ['Bob is 42', 'Julia is 35']

18. Operator overloading
Operator Method Operator Method
+ a.plus(b) a[b] a.getAt(b)
- a.minus(b) a[b] = c a.putAt(b, c)
* a.multiply(b) << a.leftShift(b)
/ a.div(b) >> a.rightShift(b)
% a.mod(b) ++ a.next()
** a.power(b) -- a.previous()
| a.or(b) +a a.positive()
& a.and(b) -a a.negative()
^ a.xor(b) ~a a.bitwiseNegative()

19. Sequence operations
'qwerty'.each {print it}
('a'..'z').each {print it}
('a'..'z').findAll { el -> // = filter
el in ['e', 'y', 'u', 'i', 'o', 'a']
}.each {
print it + ' '}
(0..10).collect { el -> // = map
el * 10
}.each {print it + ' '}

20. Working with I/O
//Adds helper methods for files
new File(baseDir, 'haiku.txt').eachLine { line ->
println line
}
//Easy to work InputStream
new File(baseDir,'haiku.txt').withInputStream { stream ->...
}
//And Writers
new File(baseDir,'haiku.txt').withWriter('utf-8') { writer ->
writer.writeLine 'Into the ancient pond'
writer.writeLine 'A frog jumps'
writer.writeLine 'Water’s sound!'
}
//get bytes
byte[] contents = file.bytes

21. AST
@TupleConstructor
@EqualsAndHashCode
@ToString for beans
@Canonical
@Sortable for beans
@Memoize for methods

22. Slupper
def jsonSlurper = new JsonSlurper()
def object = jsonSlurper.parseText '''
{ "simple": 123,
"fraction": 123.66,
"exponential": 123e12
}'''
assert object instanceof Map
assert object.simple.class == Integer
assert object.fraction.class == BigDecimal
assert object.exponential.class == BigDecimal

23. Dynamic vs Static
Groovy 2.0
without
@CompileStatic
Groovy/Java
performance
factor
Groovy 2.0
with
@CompileStatic
Groovy/Java
performance
factor
Kotlin
0.1.2580
Java
static ternary 4352ms 4.7 926ms 1.0 1005ms 924ms
static if 4267ms 4.7 911ms 0.9 1828ms 917ms
instance ternary 4577ms 2.7 1681ms 1.8 994ms 917ms
instance if 4592ms 2.9 1604ms 1.7 1611ms
969ms
@CompileStatic

24. SwissKnife
Based on both ButterKnife and AndroidAnnotations.
● Inject views like butterknife add callback methods @OnClick, @OnItemClick
● Execute methods in the UI Thread or a background one using @OnUIThread
and @OnBackground.
● Make your variables persistent across state changes without
messing with onSaveInstanceState().
● Make anything Parcelable with the @Parcelable annotation - which
can be used with @SaveInstance to automatize data persistance.
● Read intent extras automatically with @Extra annotation.

25. Q&A

26. Literature
● Groovy in Action
● http://docs.groovy-lang.org/
● Making Java Groovy
● Groovy programming: an introduction for Java
developers

27. Thanks!!!!!