Kotlin, les bases

• Qui suis-je.
• Qui êtes-vous ? Quelles sont vos attentes.
• Présentation du plan.

Qui suis-je

• Développeur d'applications mobiles Android.
• Formateur Android/Java et Kotlin (scolaires et pros).
• Co-fondateur (1/7) de Startup Marseille.
  
• Fondateur de Light4Events.
  

Qui êtes vous ?

• Prénom.
• Expérience (Java, Kotlin, Web, Mobile Android/iOS).
• Attentes.

• Pourquoi le Kotlin ?
• Introduction à la JVM (Java Virtual Machine).
• Installation des outils REPL de Kotlin (Read Eval Print Loop).
• La structure d'une application Kotlin.
• Kotlin et IntelliJ IDEA.
• Les conventions de nommage en Kotlin.

• Kotlin et Java sont 100 % interopérables.
• 2010 : idée (JetBrains).
• 2015 : naissance, disponible sur GitHub.
• Origine du nom : l'île de Kotlin.
• Concis, sûr, pragmatique et 100 % interopérable avec Java.
• Statiquement typé, mais inférence de types.
• C'est aussi un langage fonctionnel.

Inférence de type

val number = 123
val message = "Hello world !"
fun sayHello() = "Hello world !"
					

Avantages

• Performance.
• Fiabilité.
• Efficacité.

Langage fonctionnel

• First-class function.
• Immuabilité.
• Aucun effet de bord.

• En ligne de commande.
• En ligne (sur le web).
• Avec IntelliJ.

fun main() {
    println("Hello, World!")
}

kotlinc hello.kt -include-runtime -d hello.jar

java -jar hello.jar

fun main() {
    println("Hello, World!")
}

kotlinc hello.kt

program.exe

40+2
"Hello, World!"
println("Hello, World!")
1
1.0

Les répertoires

Les fichiers

Dans le fichier source

• Déclaration des propriétés et des blocs d'initialiseurs.
• Les constructeurs secondaires.
• Les déclarations des méthodes.
• L'objet compagnon.

Installation

Création du projet

Nommage

fun main() {
    println("Bonjour le monde")
}

Exécuter le code

Exécuter le code

Exécuter le code

Exécuter le code

Exécuter le code

Exécuter le code

• des Scratches : File | New | Scratch file et sélectionner le type Kotlin.
• une fenêtre REPL : Tools | Kotlin | Kotlin REPL (Control + Return pour valider)

Le scratch

• Menu : File | New | Scratch file.
• Ctrl + Alt + Shift + Inser.
• Sur Android Studio : Click droit sur app dans notre projet (par exemple), puis : New/Scratch File.

Règles de nommage

abstract class Foo { ... }

class FooImpl : Foo { ... }

fun Foo(): Foo { return FooImpl(...) }
					

Règles des espaces

• Pour indenter (4 espaces).
• Pour séparer un mot clé et une "(" (par exemple if, for ou catch.
• Pour séparer un mot clé et une "{" (par exemple else.
• Avant toute "{".
• Avant et après tout opérateur binaire.
• Avant et après la flèche ->.
• Avant et après l'opérateur d'intervalle ...
• Après une virgule ,.
• Avant et après le signe de commentaire ligne simple //.

Nommage des propriétés

const val MAX_COUNT = 8
val USER_NAME_FIELD = "UserName"

val mutableCollection: MutableSet<String> = HashSet()

val PersonComparator: Comparator<Person> = /*...*/

Choisir le bon nom

• Déclaration de variables en Kotlin.
• Utilisation de variables "Basic Types" en Kotlin.
• Les commentaires.
• Structures conditionnelles If et When.
• Boucles et ranges en Kotlin.
• Collections en Kotlin.
• Packages et imports en Kotlin.
• Gestion des exceptions.

• val : valeur
• var : variable

val message = "Hello world !"
val message: String = "Hello world !"
var message: String = "Hello world !"
					

val name: String = "Tristan"
val age: Int = 41
val isDeveloper: Boolean = true
					

val name = "Tristan"
val age = 41
val isDeveloper = true
					

import kotlin.random.Random

fun isUserHappy() = Random.nextInt(0, 100) % 2 == 0
fun main() {
    val message: String
    if (isUserHappy())
        message = "That's great"
    else
        message = "What's going on?"

    println(message)
}
					

Null safety

var name: String = "Tristan"
name = null
					

var name: String? = "Tristan"
name = null
					

Null safety (suite)

var name: String? = "Tristan"
name.toUpperCase()
					

var name: String? = "Tristan"
name?.toUpperCase()
					

Utilisation d'une variable dans une chaîne de caractère

val name = "Tristan"
println("Hello $name")
					

Les constantes

public static final String SERVER_URL = "http://my.api.com/";
					

const val SERVER_URL = "http://my.api.com/"
					

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1
					

Nombres à virgule

val pi = 3.14 // Double
val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float, actual value is 2.7182817
					

Conversion automatique des types.

fun main() {
    fun printDouble(d: Double) { println(d) }

    val i = 1
    val d = 1.1
    val f = 1.1f

    printDouble(d)
//    printDouble(i) // Error: Type mismatch
//    printDouble(f) // Error: Type mismatch
}
					

Conversion explicite.

• toByte(): Byte
• toShort(): Short
• toInt(): Int
• toLong(): Long
• toFloat(): Float
• toDouble(): Double
• toChar(): Char

Exercice

fun main() {
    fun printDouble(d: Double) { println(d) }

    val i = 1
    val d = 1.1
    val f = 1.1f

    printDouble(d)
//    printDouble(i) // Error: Type mismatch
//    printDouble(f) // Error: Type mismatch
}
	

fun check(c: Char) {
    if (c == 1) { // ERROR: incompatible types
        // ...
    }
}
					

Pour écrire un caractère, on utilise la simple "quote" '.
Exemple : 't'.
Les caractères spéciaux sont préfixés par \.
Exemple : \t, \b, \n, \r, \', \", \\ and \$.
Pour les autres caractères, on peut utiliser la syntaxe Unicode : '\uFF00'.

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // Explicit conversions to numbers
}
					

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
        // ...
}
					

var array = arrayOf(1, 2, 3)
array.forEach { println(it) }
var arrayOfNull: Array<Int?> = arrayOfNulls(5)
arrayOfNull.forEach { println(it) }
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }
					

var array = arrayOf(1, 2, 3)
println(array[2])
array[0] = 4
array.forEach { println(it) }
					

Exercice

val oddArray = TODO()
	

Exercice

val alphabetArray = TODO()
	

val s = "abc" + 1
println(s + "def")
					

Modèles (String templates)

val i = 10
println("i = $i") // affiche "i = 10"
					

println("$name.length is ${name.length}")
println("price : ${'$'}9.99")

val price = """
${'$'}9.99
"""
					

Exercice

fun hello(name: String): String = TODO()

/*
Les commentaires sur plusieurs
lignes, pour pouvoir bien s'exprimer.
Vous pouvez écrire autant que vous voulez.
*/
// ceci est un commentaire uniligne.

L'expression if

// Usage traditionnel
var max = a
if (a < b) max = b

// Avec else
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}

// Comme une expression
val max = if (a > b) a else b

L'expression if (suite)

val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}

Selon le cas (when)

var apiReponse = 404
when (apiReponse) {
    200 -> "OK"
    404 -> "NOT FOUND"
    401 -> "UNAUTHORIZED"
    403 -> "FORBIDDEN"
    else -> "UNKNOWN"
}

Tant que faire se peut (while)

var isRaining = true
while (isRaining){
    println("I don't like rain.")
}

do {
    println("I don't like rain.")
} while (isRaining)
					

Boucle pour (for loop)

for (item in collection) print(item)
					

val names = listOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")

for(name in names) {
    println("This developer rocks : $name")
}
					

Les intervalles

if (i in 1..4) {  // equivalent à 1 <= i && i <= 4
    print(i)
}
					

for (i in 1..4) print(i)
					

for (i in 4 downTo 1) print(i)
					

Les intervalles (suite)

for (i in 1..8 step 2) print(i)
println()
for (i in 8 downTo 1 step 2) print(i)
					

for (i in 1 until 10) {       // i in [1, 10), 10 is excluded
    print(i)
}
					

Break et continue

Exercice

var stringValue = "Une chaîne de caractères"
	

Exercice

• Une liste (List), est une collection ordonnée d'objets auxquels nous pouvons accéder via leur position/index (un nombre entier). Un élément peut être présent une ou plusieurs fois dans la liste. Exemple d'une phrase qui comporte des mots, dont l'ordre est important, et qui peuvent se répéter.
• Les ensembles (Set), est une collection d'éléments uniques. L'ordre dans un ensemble n'a pas d'importance. Par exemple les lettres de l'alphabet.

• Les dictionnaires (Map), est un ensemble d'élements composés d'une paire (clé-valeur). Les clés ont des valeurs uniques qui désignent un seul objet de la collection. Les valeurs peuvent apparaître en plusieurs fois. Cette structure est employée pour stocker une connexion logique entre 2 objets, par exemple, un numéro d'employé et sa fiche descriptive.

• En lecture seule (read-only/immutable).
• En lecture/écriture (mutable) (ajout, retrait, modification des éléments).

val numbers = mutableListOf("one", "two", "three", "four")
numbers.add("five")   // this is OK
//numbers = mutableListOf("six", "seven")      // compilation error
                    

val listOfNames = listOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")
listOfNames[0]
//listOfNames[0] = "Mathieu NEBRA" // Error: List is immutable

val mutableListOfNames = mutableListOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")
mutableListOfNames[0]
mutableListOfNames[0] = "Mathieu NEBRA" // OK

val setOfNames = setOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")
setOfNames.first()
//setOfNames.add("Mathieu NEBRA") // Error: Set is immutable

val mutableSetOfNames = mutableSetOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")
mutableSetOfNames.first()
mutableSetOfNames.add("Mathieu NEBRA") // OK

var arrayOfNames = arrayOf("Jake WHARTON", "Joe BIRCH", "Robert MARTIN")
var mapOfNames = mapOf(0 to "Jake WHARTON", 1 to "Joe BIRCH", 2 to "Robert MARTIN")
					

package org.example

fun printMessage() { /*...*/ }
class Message { /*...*/ }

// ...
					

• Fonctions en Kotlin
• Paramètres des fonctions en Kotlin
• Tail recursion en Kotlin

Déclaration

fun double(x: Int): Int {
    return 2 * x
}
					

Utilisation

val result = double(2)
					

Stream().read() // créé une instance de la class Stream et appelle la fonction read()
					

Les paramètres simples

fun powerOf(number: Int, exponent: Int) { /*...*/ }

Paramètres par défauts

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) { /*...*/ }

Exercice

fun upper(): String = TODO()
	

Exercice

fun add(a: Int, b: Int): Int = TODO()
	

Exercice

fun strEq(s1: String, s2: String): Boolean = TODO()
fun strEq(s1: String, s2: String, ignoreCase: Boolean): Boolean = TODO()
	

Exercice

val languages = arrayOf("Java", "JavaScript", "Go", "Kotlin")
fun printLanguages(): Unit = TODO()
	

Exercice

• tenFirstNumber() qui affiche les 10 premiers chiffres (0-9).
• countdown() qui affiche les nombres de 10 à 0.
• firstEvenNumbers() qui affiche les 10 premiers nombres pairs.
• firstOddNumbers() qui affiche les 10 premiers nombres impairs.

fun tenFirstNumber(): Unit = TODO()
fun countdown(): Unit = TODO()
fun firstEvenNumbers(): Unit = TODO()
fun firstOddNumbers(): Unit = TODO()
	

Paramètres nommés

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
/*...*/
}

Paramètres nommés utilisation

reformat(str)

reformat(str, true, true, false, '_')

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)

Les paramètres variables

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

val eps = 1E-10 // "good enough", could be 10^-15

tailrec fun findFixPoint(x: Double = 1.0): Double
        = if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))
				

val eps = 1E-10 // "good enough", could be 10^-15

private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (Math.abs(x - y) < eps) return x
        x = Math.cos(x)
    }
}
					

Retour d'une fonction

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // "return Unit" or "return" is optional
}

fun printHello(name: String?): {
    ...
}

Classes en Kotlin

• La POO.
• Une classe.
• Les attributs.
• Méthodes (Functions Members).
• Visibilité des membres en Kotlin.
• Héritage en Kotlin.
• Abstract Classes en Kotlin.
• Interface en Kotlin.
• Polymorphisme en Kotlin.
• Data Classes en Kotlin.
• Enum Classes en Kotlin.
• Nested Classes en Kotlin.
• Sealed Classes en Kotlin.

• Rassembler dans une même structure :
  • Attributs (données) ou "variables membres".
  • Méthodes (fonctions).
• Garantir l’intégrité des données en :
  • Ne laissant visible que ce qui doit être réellement utilisé (visibilité).
  • N’accédant aux données que par des méthodes.

Déclaration

class Invoice { /*...*/ }
					

class Empty
					

Le constructeur

class Person constructor(firstName: String) { /*...*/ }
					

class Person(firstName: String) { /*...*/ }
					

La forme concise du constructeur

class Person(val firstName: String, val lastName: String, var age: Int) { /*...*/ }
					

• En lecture seule : val
• En lecture ET écriture (mutable) : var

Exemple de classe User

public class User {

    // PROPERTIES
    private String email;
    private String password;
    private int age;

    // CONSTRUCTOR
    public User(String email, String password, int age) {
        this.email = email;
        this.password = password;
        this.age = age;
    }

    // GETTERS
    public String getEmail() { return email; }
    public String getPassword() { return password; }
    public int getAge() { return age; }

    // SETTERS
    public void setEmail(String email) { this.email = email; }
    public void setPassword(String password) { this.password = password; }
    public void setAge(int age) { this.age = age; }
}
					

class User(var email: String, var password: String, var age: Int)
					

Les valeurs par défaut

class Customer(val customerName: String = "")
					

Propriété privée

class User(var email: String, private var password: String, var age: Int)
					

Utilisation (instantiation) d'une classe

val user = User("hello@gmail.com", "azerty", 41)
					

val user = User("hello@gmail.com", "azerty", 41)
println(user.email) // Getter
user.email = "my_new_email@gmail.com"
println(user.email) // Getter
					

Exercice

class Address {
    var name: String = "Holmes, Sherlock"
    var street: String = "221b Baker Street"
    var city: String = "London"
    var state: String? = null
    var zip: String = "NW1 6XE"
}
					

fun copyAddress(address: Address): Address {
    val result = Address() // there's no 'new' keyword in Kotlin
    result.name = address.name // accessors are called
    result.street = address.street
    // ...
    return result
}
					

class Sample() {
    fun foo() { print("Foo") }
}

Sample().foo() // creates instance of class Sample and calls foo

• private : Un membre déclaré comme private sera visible uniquement dans la classe où il est déclaré.
• protected : Un membre déclaré comme protected sera visible uniquement dans la classe où il est déclaré ET dans ses sous-classes (via l’héritage).
• internal : Un membre déclaré comme internal sera visible par tous ceux du même module. Un module est un ensemble de fichiers compilés ensemble (comme une librairie Gradle ou Maven, par exemple).
• public : Un membre déclaré comme public sera visible partout et par tout le monde.

class Example // Implicitly inherits from Any
					

open class Base(p: Int)

class Derived(p: Int) : Base(p)
					

La surcharge des méthodes

open class Shape {
    open fun draw() { /*...*/ }
    fun fill() { /*...*/ }
}

class Circle() : Shape() {
    override fun draw() { /*...*/ }
}
					

open class Rectangle() : Shape() {
    final override fun draw() { /*...*/ }
}
					

La surcharge des propriétés

open class Shape {
    open val vertexCount: Int = 0
}

class Rectangle : Shape() {
    override val vertexCount = 4
}
					

interface Shape {
    val vertexCount: Int
}

class Polygon : Shape {
    override var vertexCount: Int = 0  // Can be set to any number later
}
					

L'appel à la classe parente

open class Rectangle {
    open fun draw() { println("Drawing a rectangle") }
    val borderColor: String get() = "black"
}

class FilledRectangle : Rectangle() {
    override fun draw() {
        super.draw()
        println("Filling the rectangle")
    }

    val fillColor: String get() = super.borderColor
}
					

open class Polygon {
    open fun draw() {}
}

abstract class Rectangle : Polygon() {
    override abstract fun draw()
}
					

interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}
					

class Child : MyInterface {
    override fun bar() {
        // body
    }
}
					

open class User (var name: String, var firstName: String, var age: Int) {
    open fun displayInformations() = println("$firstName $name is $age old")
}
class Admin(name: String, firstName: String, age: Int, var phoneNumber: String) : User(name, firstName, age) {
    override fun displayInformations() = println("$firstName $name is $age old, phone number : $phoneNumber")
}

fun main() {
    var currentUser = User(firstName = "Tristan", name = "SALAUN", age = 41)
    currentUser.displayInformations()
    currentUser = Admin(firstName = "Tristan", name = "SALAUN", age = 41, phoneNumber = "0123456789")
    currentUser.displayInformations()
}

Exercice

interface Animal {
  fun speak()
}

class Dog: Animal
class Bird: Animal
class Duck: Animal
class Snake: Animal
	

Surcharge de fonctions

fun printNumber(n : Number){
    println("Using printNumber(n : Number)")
    println(n.toString() + "\n")
}

fun printNumber(n : Int){
    println("Using printNumber(n : Int)")
    println(n.toString() + "\n")
}

fun printNumber(n : Double){
    println("Using printNumber(n : Double)")
    println(n.toString() + "\n")
}

Surcharge de fonctions

fun main() {
    val a : Number = 99
    val b = 1
    val c = 3.1

    printNumber(a) //Which version of printNumber is getting used?
    printNumber(b) //Which version of printNumber is getting used?
    printNumber(c) //Which version of printNumber is getting used?
}

data class User(val name: String, val age: Int)
					

• equals()/hashCode().
• toString() sous la forme "User(name=Tristan, age=40)".
• Les fonctions componentN() correspondant aux propriétés dans leur ordre de déclaration.
• La fonction copy().

Exercice

data class Person (var firstName: String = "", var lastName: String = "")
	

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}
					

Initialisation

enum class Color(val rgb: Int) {
        RED(0xFF0000),
        GREEN(0x00FF00),
        BLUE(0x0000FF)
}
					

Exercice

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}
fun main() {
    val direction = Direction.NORTH
    when{
        true -> TODO()
    }
}
	

class Outer {
    private val bar: Int = 1
    class Nested {
        fun foo() = 2
    }
}

val demo = Outer.Nested().foo() // == 2
					

Classes imbriquées

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}

val demo = Outer().Inner().foo() // == 1
					

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
					

fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}
					

Exemple sans classe scellée

data class Substract(val e1: Expr, val e2: Expr) : Expr()
data class Multiply(val e1: Expr, val e2: Expr) : Expr()
data class Divide(val e1: Expr, val e2: Expr) : Expr()
	

• Operator Overloading en Kotlin
• Lambda expression en Kotlin
• Extensions de fonctions en Kotlin
• Extensions de propriétés en Kotlin
• Closures en Kotlin
• Bonnes et mauvaises pratiques

Les opérations unaires

data class Point(val x: Int, val y: Int)

operator fun Point.unaryMinus() = Point(-x, -y)

val point = Point(10, 20)

fun main() {
    println(-point)  // prints "Point(x=-10, y=-20)"
}
                

Les opérations incrément et décrément

Exercice

data class Point(var x: Int, var y: Int)
	

Les opérations binaires

Les opérations arithmétiques

Exemple

data class Counter(val dayIndex: Int) {
    operator fun plus(increment: Int): Counter {
        return Counter(dayIndex + increment)
    }
}

fun main() {
    var counter: Counter = Counter(0)

    println(counter)
    println(counter + 3)
}

Exercice

data class Point(var x: Int, var y: Int)
	

L'opérateur 'In'

Opérateur d'accès indexé

Opérateur d'invocation

Opérateur d'affectation étendus

Opérateurs d'égalité et d'inégalité

fun main() {
    val first = Integer(10)
    val second = Integer(10)

    println(first == second)       // 1
    println(first.equals(second))  // 2
    println(first === second)      // 3
}

• 1 => true
• 2 => true
• 3 => false

Opérateurs de comparaison

Fonctions d'ordre supérieur

fun <T, R> Collection<T>.fold(
    initial: R,
    combine: (acc: R, nextElement: T) -> R
    ): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

val items = listOf(1, 2, 3, 4, 5)

// Lambdas are code blocks enclosed in curly braces.
items.fold(0, {
    // When a lambda has parameters, they go first, followed by '->'
    acc: Int, i: Int ->
    print("acc = $acc, i = $i, ")
    val result = acc + i
    println("result = $result")
    // The last expression in a lambda is considered the return value:
    result
})

// Parameter types in a lambda are optional if they can be inferred:
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })

// Function references can also be used for higher-order function calls:
val product = items.fold(1, Int::times)

Expression lambda et fonctions anonymes

max(strings, { a, b -> a.length < b.length })

fun compare(a: String, b: String): Boolean = a.length < b.length

Syntaxe de l'expression lambda

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

val sum = { x: Int, y: Int -> x + y }

Passer une lambda en paramètre

val product = items.fold(1) { acc, e -> acc * e }

run { println("...") }

it : le nom implicite du paramètre unique

var ints = listOf(0, 1,-2,3,-1)
ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'

Exercice

val sum = TODO()
	

Exercice

inline fun executeOperation(x: Int, y: Int, operation: (Int, Int) -> Int) = operation(x, y)
	

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.d(TAG, "User clicked button");
    }
});
                        

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.d(TAG, "User clicked button");
    }
});
                        

button.setOnClickListener ( v -> {
    Log.d(TAG, "User clicked button");
});
                        

button.setOnClickListener( { v: View -> Log.d(TAG, "User clicked button"); })
                        

button.setOnClickListener( { v: View -> Log.d(TAG, "User clicked button"); } )
                        

button.setOnClickListener( { v: View -> Log.d(TAG, "User clicked button")  } )
                        

button.setOnClickListener() { v: View -> Log.d(TAG, "User clicked button")  }
                        

button.setOnClickListener   { v: View -> Log.d(TAG, "User clicked button")  }
                        

button.setOnClickListener   { v       -> Log.d(TAG, "User clicked button")  }
                        

button.setOnClickListener   {            Log.d(TAG, "User clicked button")  }
                        

button.setOnClickListener{ Log.d( TAG, "User clicked button" ) }
                        

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.d(TAG, "User clicked button");
    }
});
                        

button.setOnClickListener ( v -> {
    Log.d(TAG, "User clicked button");
});
                        

Extensions de fonctions en Kotlin

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' corresponds to the list
    this[index1] = this[index2]
    this[index2] = tmp
}

val list = mutableListOf(1, 2, 3)
list.swap(0, 2) // 'this' inside 'swap()' will hold the value of 'list'

Exercice

fun String.firstUpper(): Any = TODO()
	

Extensions de propriétés en Kotlin

val <T> List<T>.lastIndex: Int
    get() = size - 1

Exercice

var StringBuilder.firstLetter: Char
    get() = TODO()
    set(value) = TODO()
	

• Concept de délégation en Kotlin
• Délégation de fonctions en Kotlin
• Délégation de propriétés en Kotlin
• Bonnes et mauvaises pratiques

Exemple en Kotlin

interface Nameable {
    var name: String
}

class JackName : Nameable {
    override var name: String = "Jack"
}

class LongDistanceRunner: Runnable {
    override fun run() {
        println("long")
    }
}

class Person(name: Nameable, runner: Runnable): Nameable by name, Runnable by runner

fun main(args: Array<String>) {
    val person = Person(JackName(), LongDistanceRunner())
    println(person.name) //Jack
    person.run() //long
}

Exercice

fun displayPerson(person: Person){
    println(person.name)
    person.run()
}
	

Exercice

class Foo {
    var prop: String? = null
}

val foo = Foo()
foo.prop = "something"
val another = foo.prop

var str: String
    get() = this.toString()
    set(value) {
        println(value)
        field = value
    }

import kotlin.reflect.KProperty

class Example {
    val someName by NameDelegate()
    val otherName by NameDelegate()
}

class NameDelegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return property.name
    }
}

fun main() {
    val example = Example()
    println(example.someName)
    println(example.otherName)
}

import kotlin.reflect.KProperty

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

Delegate standards

• "lazy properties" : les valeurs sont calculées lors du premier accès.
• "observable properties" : les listeners sont notifiés lors des changements de la propriété.
• "vetoable properties" : il est possible de mettre un veto sur le changement d'une valeur.
• "notNull properties" : permet de vérifier que la valeur est définie avant un premier accès.

class Box<T>(t: T) {
    var value = t
}

val box: Box<Int> = Box<Int>(1)

val box = Box(1) // 1 est de type Int, donc le compilateur peut en déduire que nous utilisons un type : Box<Int>

• Casting de types en Kotlin
• Tuples
• Deconstructing Values
• Gestion des exceptions
• Déclaration de constantes
• Annotation en Kotlin
• Bonnes et mauvaises pratiques

fun foo(x: Any) {
    if (x is Person) {
        println("${x.name}") // This wouldn't compile outside the if
    }
}

val p = x as Person

val p = x as? Person

Exercice

class Person(var name: String)
class Other()
	

val value = "Message"
println(value as? Int)
println(value as Int?)
	

Exercice

import java.util.ArrayList;
import java.util.List;

public class Test {

    private static int getDefaultSize(Object object){
        if(object instanceof String) {
            return ((String) object).length();
        } else if(object instanceof List) {
            return ((List) object).size();
        }
        return 0;
    }

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        System.out.println(getDefaultSize(list));
        System.out.println(getDefaultSize("list"));
    }
}
	

Les types standards

• Pair : qui contient 2 éléments.
• Triple : qui contient 3 éléments.

Pair

• first contient la première valeur.
• second contient la seconde valeur.

Triple

• first contient la première valeur.
• second contient la seconde valeur.
• third contient la troisième valeur.

Exercice

data class Pair<out A, out B> : Serializable
data class Triple<out A, out B, out C> : Serializable
	

data class Person(var name:String, var age: Int)
val tristan = Person("Tristan", 40)
val (name, age) = tristan

println(name)
println(age)

val name = person.component1()
val age = person.component2()

for ((a, b) in collection) { ... }

Exemple : retourner deux valeurs depuis une fonction

data class Result(val result: Int, val status: Status)
fun function(...): Result {
    // computations

    return Result(result, status)
}

// Now, to use this function:
val (result, status) = function(...)

Exercice

Les classes d'exception

throw Exception("Hi There!")

try {
    // some code
}
catch (e: SomeException) {
    // handler
}
finally {
    // optional finally block
}

Try est une expression

val numValue: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

Exercice

val numValue: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }
	

const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"

@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }
					

Pour les méthodes

companion object {
    private const val TAG = "ClassName"
}

public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}
					

lateinit var allByDefault: String // error: explicit initializer required, default getter and setter implied
print(allByDefault) // KO, Exception : kotlin.UninitializedPropertyAccessException: lateinit property allByDefault has not been initialized
					

Vérification initialisation tardive

if (foo::bar.isInitialized) {
    println(foo.bar)
}
					

lateinit var allByDefault: String // error: explicit initializer required, default getter and setter implied
print(allByDefault) // KO, Exception : kotlin.UninitializedPropertyAccessException: lateinit property allByDefault has not been initialized
					

Utilisation de lateinit

class MyTest() {
    lateinit var subject: String

    fun displaySubject() {
        println(subject)
    }
}

fun main() {
    var myTest = MyTest()
    myTest.displaySubject()
}
	

Définition

• Interopérabilité avec Java.
• De Kotlin au Java.
• Nulls de Java.
• Le Kotlin dans Java.
• Java Réflexion avec Kotlin.
• Kotlin Réflexion.

import java.util.*

fun demo(source: List<Int>) {
    val list = ArrayList<Int>()
    // 'for'-loops work for Java collections:
    for (item in source) {
        list.add(item)
    }
    print(list)

    // Operator conventions work as well:
    for (i in 0..source.size - 1) {
        list[i] = source[i] // get and set are called
    }
    print(list)
}
                

fun main() {
    demo(listOf(1,3,5,74,1,-2,5,98))
}

Getters et Setters

import java.util.Calendar

fun calendarDemo() {
    val calendar = Calendar.getInstance()
    if (calendar.firstDayOfWeek == Calendar.SUNDAY) {  // call getFirstDayOfWeek()
        calendar.firstDayOfWeek = Calendar.MONDAY      // call setFirstDayOfWeek()
    }
    if (!calendar.isLenient) {                         // call isLenient()
        calendar.isLenient = true                      // call setLenient()
    }
}

fun main() {
    calendarDemo()
}

Un autre exemple

public class Customer {

    private String firstName;
    private String lastName;
    private int age;

    //standard setters and getters
}

Utilisation en Kotlin

fun main() {
    val customer = Customer()

    customer.firstName = "Frodo"
    customer.lastName = "Baggins"

    println("${customer.firstName} ${customer.lastName}")
}

Remarques

Appeler du Kotlin en Java

Les propriétés

• Une méthode getter, sera formatée en préfixant le nom de la propriété par get.
• Une méthode setter, sera formatée en préfixant le nom de la propriété par set(pour les propriétés de type var).
• Un champ privé aura le même nom que le nom de la propriété.

private String firstName;

public String getFirstName() {
    return firstName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

Propriétés (suite)

Exercice

var firstName = ""
var isOpen = false
	

Les fonctions au niveau du package

// app.kt
package org.example
class Util

fun getTime(): Int { println("10h21"); return 10 }

// Java
import org.example.AppKt;
import org.example.Util;

public class Test {

   Util utilVar = new Util();
   int timeValue = AppKt.getTime();
}

statics / const

// file example.kt
object Obj {
    const val CONST = 1
}

class C {
    companion object {
        const val VERSION = 9
    }
}

const val MAX = 239

// Java
int const = Obj.CONST;
int max = ExampleKt.MAX;
int version = C.VERSION;

La classe Kotlin

// Shape.kt
class Shape(var width: Int, var height: Int, val shape: String) {
    var area: Int = 0
    fun shapeMessage() {
        println("Hi i am $shape, how are you doing")
    }
    fun draw() {
        println("$shape is drawn")
    }
    fun calculateArea(): Int {
        area = width * height
        return area
    }
}

L'appel en Java

public class FromKotlinClass {
    public static void callShapeInstance() {
        Shape shape = new Shape(5,5,"Square");
        shape.shapeMessage();
        shape.setHeight(10);
        System.out.println(shape.getShape() + " width " + shape.getWidth());
        System.out.println(shape.getShape() + " height " + shape.getHeight());
        System.out.println(shape.getShape() + " area " + shape.calculateArea());
        shape.draw();
    }
    public static void main(String[] args) {
        callShapeInstance();
    }
}

Appel d'un Singleton Kotlin

// Kotlin
object Singleton {
    fun happy() {
        println("I am Happy")
    }
}

// Java
public static void main(String args[]) {
    Singleton.INSTANCE.happy();
}

Appel d'un Singleton (suite)

object Singleton {

    fun happy() {
        println("I am Happy")
    }

    @JvmStatic fun excited() {
        println("I am very Excited")
    }
}

public static void main(String args[]) {
    Singleton.INSTANCE.happy();
    Singleton.excited();
}

Appel de fonctions top level

fun logD(message: String) {
    Log.d("", message)
}
fun logE(message: String) {
    Log.e("", message)
}

UtilsKt.logD("Debug");
UtilsKt.logE("Error");

Exercice

public class Customer {

    private String firstName;
    private String lastName;
    private int age;

    //standard setters and getters
}

• <ClassName>::class.java permet de récupérer la classe.
• la propriété constructors de Class<T> contient le tableau des constructeurs.
• la propriété name du Constructor contient le non du constructeur.

reflexion Java en Kotlin

MyClass::class.java.methods

• MyClass::class nous donne une représentation de la class MyClass
• .java nous donne l'équivalent de java.lang.Class
• .methods appelle la méthode java.lang.Class.getMethods()

data class ExampleDataClass(
    val name: String, var enabled: Boolean)

fun main() {
    ExampleDataClass::class.java.methods.forEach(::println)
}

Mise en place du projet

Nommage du module

Nommage du projet

Ajoutez la dépendance

dependencies {
    ...
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
}

launch {
//    ...
}

println("Start")

// Start a coroutine
GlobalScope.launch {
    delay(1000)
    println("Hello")
}

Thread.sleep(2000) // wait for 2 seconds
println("Stop")

Blocage du thread principal

runBlocking {
    delay(2000)
}

import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() {
    println("Start")

// Start a coroutine
    GlobalScope.launch {
        delay(1000)
        println("Hello")
    }

    // Step 1
    //Thread.sleep(2000) // wait for 2 seconds

    // Step 2
    //    delay(2000)

    // Step 3
    runBlocking {
        delay(2000)
    }
    println("Stop")
}

Lançons beaucoup de thread

val c = AtomicLong()

for (i in 1..1_000_000L)
    thread(start = true) {
        c.addAndGet(i)
    }

println(c.get())

Lançons beaucoup de thread

val c = AtomicLong()

for (i in 1..1_000_000L)
    GlobalScope.launch {
        c.addAndGet(i)
    }

println(c.get())

val deferred = (1..1_000_000).map { n ->
    GlobalScope.async {
        n
    }
}
val sum = deferred.sumBy { it.await() }
println("Sum: $sum")

val deferred = (1..1_000_000).map { n ->
    GlobalScope.async {
        n
    }
}
runBlocking {
    val sum = deferred.sumBy { it.await() }
    println("Sum: $sum")
}

Sum: 1784293664

Parallèle

val deferred = (1..1_000_000).map { n ->
    GlobalScope.async {
        delay(1000)
        n
    }
}
runBlocking {
    val sum = deferred.sumBy { it.await() }
    println("Sum: $sum")
}

fonctions suspendues

fun workload(n: Int): Int {
    delay(1000)
    return n
}

suspend fun workload(n: Int): Int {
    delay(1000)
    return n
}

Code final

import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking

fun main() {

    suspend fun workload(n: Int): Int {
        //delay(3000)
        return n
    }

    val deferred = (1..1_000_000).map { n ->
        GlobalScope.async {
            workload(n)
        }
    }
    runBlocking {
        val sum = deferred.sumBy { it.await() }
        println("Sum: $sum")
    }
}

L'application IMC

• Installer et lancer Android Studio.
• Créér un projet : IMC.
• Mettre en place le view binding.
• Définir notre interface graphique.
• Implémenter le code métier.

Installer et lancer Android Studio

Créer un projet : IMC

Mettre en place le view binding

Définir notre interface graphique

Implémenter le code métier

• Écouter les changements de valeur des champs textes.
• Calculer et afficher la valeur de l'IMC avec la formule : poids / taille (en m)².
• Afficher des indications supplémentaires.
• Enregistrer la taille.

Optimisation

• Mémoire
• Processeur
• Radio (WiFi, 3G, BT)
• Graphique

Le cycle développement

1. Lancement : toutes les applications commencent par une idée. Cette idée est généralement affinée jusqu’à constituer une base solide pour une application.
2. Conception : la phase de conception consiste à définir l’expérience utilisateur de l’application, comme la présentation générale, son fonctionnement, etc., ainsi que la conversion de cette expérience utilisateur en une interface utilisateur appropriée, généralement avec l’aide d’un infographiste.
3. Développement : généralement la phase la plus consommatrice de ressources, c’est la phase de création réelle de l’application.
4. Stabilisation : quand le développement est suffisamment avancé, l’assurance qualité commence généralement à tester l’application et les bogues sont corrigés. Le plus souvent, une application passe par une phase bêta limitée, durant laquelle un public plus large a la possibilité de l’utiliser, de fournir des commentaires et d’obtenir des modifications.
5. Déploiement

Conception des interfaces utilisateur

Phases de développement

• Prototype/MVP : l’application est toujours en phase de preuve de concept, et seules les fonctionnalités principales ou des parties spécifiques de l’application fonctionnent. Des bogues majeurs y sont présents.
• Alpha : les fonctionnalités principales sont généralement entièrement présentes dans le code (qui est généré, mais pas entièrement testé). Des bogues majeurs sont encore présents, des fonctionnalités périphériques peuvent ne pas encore être présentes.
• Bêta : la plupart des fonctionnalités sont maintenant terminées, une partie des tests et de la correction des bogues a été effectuée. Des problèmes majeurs connus peuvent encore être présents.
• Version Release Candidate : toutes les fonctionnalités sont terminées et testées. Sauf si de nouveaux bogues apparaissent, l’application est candidate à la publication.

• Activity
• Fragment (3.0+)
• Service
• Content providers
• Broadcast receivers
• Intent

1. La liste des fichiers.
2. La zone d'édition.
3. Les logs.

1. Le code de notre application.
2. Le répertoire des ressources.
3. Le répertoire contenant les mises en forme des écrans (les layouts).
4. Le répertoire contenant les versions des icônes de l'application.
5. Le répertoire contenant les autres ressources.

1. Le chemin complet du fichier courant sélectionné.

1. Le choix de la cible pour lancer le programme.
2. Relancer l'application.
3. Relancer l'activity.
4. Relancer en mode débug.
5. Attacher à la volée le debugger.

1. Nous pouvons choisir le device sur lequel se connecter.
2. Sélectionner le process pour filtrer les messages.
3. Sélectionner le type de log des messages.
4. Filtrer les messages.
5. Activer le filtre.

1. Le manifest (AndroidManifest.xml), qui contient la carte d'identité de notre application.
2. Le code de l'application.
3. Le code des test graphiques.
4. Le code des test unitaires.
5. Les ressources graphiques.
6. Les écrans (layouts) de notre application.
7. Les ressources (texte, couleurs, dimensions, styles, ...) de notre application.
8. Le fichier de configuration global du système de compilation (gradle).
9. Le fichier de configuration de notre projet (celui qui sera le plus souvent modifié).

Choix de la machine virtuelle

• Le nom du package, qui doit être unique sur le Google Play.
• Les interfaces avec l'extérieur : les activities, les services, ...
• Les permissions que nous allons utiliser.
• Le matériel nécessaire à notre application (NFC, Bluetooth, ...).

Exemple

                    
                    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example.myapplication">

    <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

La production de l'application

• Le code de l'application.
• Les ressources.
• Les assets.
• Les certificats/signatures
• Le Manifest

La publication

• F-Droid (applications open source)
• XDA Developers
• APK Miror
• App brain
• Amazon
• GETJAR
• Uptodown App Store
• Aptoide
• QooApp

• Huawei AppGallery
• Samsung Galaxy App
• Boutique Mi

LinearLayout Exercice 1

LinearLayout Exercice 2

LinearLayout Exercice 3

LinearLayout Exercice 4

LinearLayout Exercice 5

LinearLayout Exercice 6

Afficher un contenu très grand

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
            android:layout_width="match_parent"
            android:layout_height="match_parent">

    <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

        <Button
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="BTN" />

    </LinearLayout>
</ScrollView>

RelativeLayout Exercice 1

• Centré horizontalement
• Centré verticalement
• Centré dans le parent

RelativeLayout Exercice 2

• En haut
• En bas
• A gauche
• A droite
• Ces soirées là ! (centrée dans le parent)

RelativeLayout Exercice 3

• [I] En haut a gauche par défaut
• [II] En dessous de [I]
• [III] En dessous et à droite de [I]
• [IV] au dessus de [V], bord aligné avec le bord gauche de [II]
• [V] En bas à droite

TableLayout Exercice 1

ConstraintLayout Exercice 1

Les différentes ressources

• anim : des animations que l'on peut utiliser pour animer des éléments de notre interface graphique.
• drawable : des images, bitmap ou vectorielles.
• layout : l'organisation de nos écrans.
• menu : la description des menus (des activités, des fragments, ...)
• mipmap : les icônes de notre application.
• raw : des données brutes (mp3 par exemple).
• xml : des données en XML.

Les différentes ressources

• values
  • arrays : des tableaux (de chaînes de caractères ou d'entiers)
  • colors : la définition de nos couleurs.
  • bools : des boolééns.
  • dimens : des dimensions (tailles d'images, de texte, de marges, ...).
  • integers : des valeurs numériques.
  • plurials : des chaînes de caractères prenant en compte le pluriel.
  • strings : nos chaînes de caractères.
  • styles : pour afficher nos éléments.

Accéder aux valeurs en Kotlin

[package.]R.type.nom

// Par exemple
R.string.app_name

Accéder aux valeurs en XML

@[package:]type/nom

// Par exemple :
@string/app_name

Internationalisation

• Ajouter une langue.
• Ajouter des clés.
• Tester dans l'éditeur.
• Tester sur l'émulateur.
• Tester sur le téléphone.

Apostrophes et guillemets

<string name="good_example">"This'll work"</string>
<string name="good_example_2">This\'ll also work</string>
<string name="bad_example">This doesn't work</string>
<string name="bad_example_2">XML encodings don't work</string>

Formatage valeurs

<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string>

Resources res = getResources();
String text = String.format(res.getString(R.string.welcome_messages), username, mailCount);

Le pluriel

<?xml version="1.0" encoding="utf-8"?>
                <resources>
                    <plurals name="numberOfSongsAvailable">
                <!– zero, one, two, few, many, other -->
                        
                        <item quantity="one">%d song found.</item>
                        <<item quantity="other">%d songs found.</item>
                    </plurals>
                </resources>

Exemple d'utilisation du pluriel

int count = getNumberOfsongsAvailable();
Resources res = getResources();
String songsFound = res.getQuantityString(R.plurals.numberOfSongsAvailable, count, count);

Mise en forme

<b> for bold text.
<i> for italic text.
<u> for underline text.
                

<string name="welcome">Welcome to <b>Android</b>!</string>
                

Tableaux

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="planets_array">
        <item>Mercury</item>
        <item>Venus</item>
        <item>Earth</item>
        <item>Mars</item>
    </string-array>
</resources>
                

val planets = resources.getStringArray(R.array.planets_array)
                

Dimens

• px : mesure en pixel, à banir.
• dp : mesure qui s'adapte à la densité de pixel de l'écran.
• sp : mesure utilisée pour les textes, car elle prend en compte le paramétrage de l'utilisateur relatif à la taille de la police de caractère.

Colors

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#6200EE</color>
    <color name="colorPrimaryDark">#3700B3</color>
    <color name="colorAccent">#03DAC5</color>
</resources>
                

Styles

<style name="Counter" parent="AppTheme">
    <item name="android:textColor">@color/l4e_counter_text</item>
    <item name="android:background">@drawable/rounded_corner</item>
    <item name="android:padding">@dimen/l4e_counter_padding</item>
</style>

<style name="DialogTitle" parent="AppTheme">
    <item name="android:padding">@dimen/l4e_dialog_title_text_padding</item>
    <item name="android:textSize">@dimen/l4e_dialog_title_text_size</item>
    <item name="android:textStyle">bold</item>
</style>
                

Mise en place

• Récupération des templates (clé usb).
• File/Import Settings.
• Settings.jar.
• File/Invalidate caches/Restart...
• Just Restart.
• File/Settings.
• Editor/LiveTemplates.
• AndroidTristanKotlin.

Utilisation

Ajout d'un bouton

• Par héritage
• Classe anonyme
• Attribut
• XML

Par héritage

• Faisons étendre notre MainActivity de View.OnClickListener.
• Implémentons la méthode en utilisant l'ampoule rouge proposée par l'éditeur.
• Remplissons la méthode onClick générée.
• Associons notre listener à un bouton

when(v?.id){
    R.id.activity_main_button_test -> Log.d(TAG, "onCreate click")
}
                

findViewById<Button>(R.id.activity_main_button_test).setOnClickListener(this@MainActivity)
                

Par attribut

private var btnListener: View.OnClickListener = View.OnClickListener {
    when (it?.id) {
        R.id.activity_main_button_test -> Log.d(TAG, "onCreate click")
    }
}
                

findViewById<Button>(R.id.activity_main_button_test).setOnClickListener(btnListener)
                

Par lambda

findViewById<Button>(R.id.activity_main_button_test).setOnClickListener(){ Log.d(TAG, "onCreate click") }
                

Par XML

android:onClick="handleClick"
                

Éditeur code

Éditeur code/design

Éditeur code/design

Button

<Button
    android:id="@+id/activity_main_button_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="handleClick"
    android:text="Button"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Texte affiché

<TextView
    android:id="@+id/activity_main_textView_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="handleClick"
    android:text="Hello world."
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Champ texte

<EditText
    android:id="@+id/activity_main_editText_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="handleClick"
    android:hint="Enter your first name"
    android:inputType="textPersonName"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Case à cocher

<CheckBox
    android:id="@+id/activity_main_checkBox_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="handleClick"
    android:hint="Is activated ?"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

Boutons de choix

<RadioGroup
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent">

    <RadioButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Thé" />

    <RadioButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Café" />

</RadioGroup>
                

Liste de choix

Barre de progression

<ProgressBar
    android:id="@+id/activity_main_progressBar_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:indeterminate="true"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Notation (étoiles)

<RatingBar
    android:id="@+id/activity_main_ratingBar_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:numStars="5"
    android:rating="4"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Date

                    
<DatePicker
    android:id="@+id/activity_main_datePicker_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintTop_toTopOf="parent" />
                

Time

                    
<TimePicker
    android:id="@+id/activity_main_timePicker_test"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
                

Vue Web

<WebView
        android:id="@+id/activity_main_webView_test"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
                

Vue Web (suite)

var webView = findViewById<WebView>(R.id.activity_main_webView_test)
webView.loadUrl("http://light4events.fr")
                

LiveTemplates Intent

• android_intent_mail : pour envoyer un email avec les champs pré-remplis.
• android_intent_map : pour ouvrir l'application Maps affichant une coordonnée.
• android_intent_phone_call : pour lancer le numéroteur téléphonique.
• android_intent_sms : pour envoyer un SMS (pour lancer l'application de SMS, prête à envoyer le SMS).
• android_intent_web : pour lancer un navigateur web pour afficher une URL.

<intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
                

Mode développeur

• Allons dans les paramètres.
• A propos du téléphone.
• Cliquons plusieurs fois sur le numéro de build.
• Une fois débloqué, nous pouvons activer le mode débugger, et la connexion USB.

Les références

• La référence : https://kotlinlang.org/docs/reference
• La source : https://github.com/JetBrains/kotlin
• Ressource très complète en FR : https://code.i-harness.com/fr/docs/kotlin/index
• Autre ressource très complète en FR : https://riptutorial.com/Download/kotlin-fr.pdf
• Rappels des bases : https://kotlinlang.org/docs/reference/basic-syntax.html

Cours en ligne

Tests/Challenges

Articles sur des points précis

Livres

Liste des mots clés

Kotlin pour les applications Backend

Kotlin pour Android