25 - Annexes

Objectifs pédagogiques

À la fin de ce chapitre, vous serez capable de :

1. Retrouver la définition de plus de 200 termes du vocabulaire mobile
2. Consulter les cheat sheets Kotlin, Swift, Compose, SwiftUI, Dart, Flutter et React Native
3. Reconnaître et appliquer les design patterns mobile
4. Utiliser ces annexes comme référence rapide pendant le cours et en production

Plan du chapitre

Fichiers du chapitre

Temps estimé

• Lecture du glossaire : 1 h
• Parcours des cheat sheets : 2 h
• Exercices d'application : 3 h

---

Section 1 — Glossaire (200+ termes)

1.1 Langages et fondamentaux (25 termes)

1.2 Android (30 termes)

1.3 iOS (30 termes)

1.4 Cross-platform (25 termes)

1.5 Architecture et données (30 termes)

1.6 Networking et backend (20 termes)

1.7 Testing et DevOps (25 termes)

1.8 Sécurité et divers (20 termes)

Total : 25 + 30 + 30 + 25 + 30 + 20 + 25 + 20 = 205 termes.

---

Section 2 — Cheat sheet Kotlin

Variables et types

val name = "Ada"          // immuable (read-only)
var age = 36              // mutable
val email: String? = null // null-safe
val list = listOf(1, 2, 3)        // liste immuable
val map = mapOf("a" to 1, "b" to 2)
val set = setOf(1, 2, 2)          // {1, 2}

Fonctions et classes

fun add(a: Int, b: Int) = a + b        // expression body
data class User(val id: Int, val name: String)  // equals/hash/copy
fun User.displayName(): String = name   // extension function
val user = User(1, "Ada")
val copy = user.copy(name = "Grace")

Null-safety

val a: String? = null
a?.length          // null si a est null
a ?: "default"     // Elvis : valeur par défaut
a!!               // force (à éviter !)
val len: Int = a?.length ?: 0

Coroutines

viewModelScope.launch {
    val result = withContext(Dispatchers.IO) { fetch() }
    uiState.value = result
}
val deferred = async { fetchA() }        // parallèle
val b = async { fetchB() }
launch { doSomething() }                  // fire-and-forget
flow { emit(1); emit(2) }                 // Flow froid
flow.map { it * 2 }.filter { it > 1 }.collect { ... }

Collections (fonctionnelles)

list.filter { it > 1 }
list.map { it * 2 }
list.fold(0) { acc, x -> acc + x }
list.any { it > 5 }
list.groupBy { it % 2 }
list.sortedBy { it }

---

Section 3 — Cheat sheet Swift

Variables et types

let name = "Ada"              // constante
var age = 36                  // variable
var email: String? = nil      // optionnelle
let list = [1, 2, 3]          // Array
let dict = ["a": 1, "b": 2]   // Dictionary
let set: Set<Int> = [1, 2, 3]

Optionals

var name: String? = "Ada"
if let name = name { print(name) }   // if let
guard let name = name else { return } // guard (early exit)
let count = name?.count ?? 0         // ?? et chaînage

Struct / Enum / Protocol

struct User: Identifiable {
    let id: Int
    var name: String
}

enum Status {
    case pending, active, done
}

protocol Processable {
    func process() async throws
}
extension Processable {
    func log() { print("processing") }   // implémentation par défaut
}

Fonctions et closures

func add(_ a: Int, _ b: Int) -> Int { a + b }   // label omis
let multiply = { (a: Int, b: Int) -> Int in a * b }
let values = [1, 2, 3].map { $0 * 2 }

Concurrence

func load() async throws -> Data {
    let (data, response) = try await URLSession.shared.data(from: url)
    return data
}
async let a = fetchA()   // parallèle
async let b = fetchB()
let results = try await (a, b)

actor Counter {
    private var value = 0
    func increment() { value += 1 }
}

Erreurs

enum AppError: Error { case network, notFound }
func fetch() throws -> Data { ... }
do { try fetch() } catch { print(error) }

---

Section 4 — Cheat sheet Jetpack Compose

Composables et état

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) { Text("$count") }
}

Disposition

Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
    Row(horizontalArrangement = Arrangement.SpaceBetween) { ... }
    Box(modifier = Modifier.fillMaxSize()) { ... }          // empilement
}

Listes

LazyColumn {
    items(items = list, key = { it.id }) { item -> ... }
}

Thème

MaterialTheme(
    colorScheme = if (darkTheme) darkColorScheme() else lightColorScheme(),
    typography = Typography()
) { ... }

Navigation

NavHost(navController, startDestination = "home") {
    composable("home") { HomeScreen(onClick = { navController.navigate("detail/1") }) }
    composable("detail/{id}") { backStackEntry -> DetailScreen(backStackEntry.arguments?.getString("id")) }
}

Modificateurs utiles

Modifier
    .fillMaxWidth().padding(16.dp)
    .clickable { ... }
    .clip(RoundedCornerShape(8.dp))
    .background(color)
    .size(48.dp)

---

Section 5 — Cheat sheet SwiftUI

Vues et état

struct CounterView: View {
    @State private var count = 0
    var body: some View {
        Button("\(count)") { count += 1 }
    }
}

Disposition

VStack(spacing: 8) {
    HStack { Text("A"); Spacer(); Text("B") }
    ZStack { Circle(); Text("badge").offset(...) }
    ScrollView { ForEach(items) { item in Text(item.title) } }
}

Listes et navigation

NavigationStack {
    List(users) { user in
        NavigationLink(value: user) { Text(user.name) }
    }
    .navigationDestination(for: User.self) { user in UserDetail(user: user) }
}

Concurrence dans la vue

.task { await viewModel.load() }          // annulé automatiquement

Préviews

#Preview {
    ContentView()
        .environment(\.colorScheme, .dark)
}

Modificateurs clés

Text("Hello")
    .font(.title)
    .foregroundStyle(.blue)
    .padding()
    .background(RoundedRectangle(cornerRadius: 8))
    .frame(maxWidth: .infinity)
    .onTapGesture { ... }

---

Section 6 — Cheat sheet Dart

Variables et types

final name = 'Ada';        // read-only
var age = 36;              // mutable
String? email;             // nullable
final list = [1, 2, 3];
final map = {'a': 1, 'b': 2};
final set = {1, 2, 3};

Fonctions et classes

int add(int a, int b) => a + b;
class User {
  final int id;
  final String name;
  const User(this.id, this.name);
}

Contrôle de flux

if (email == null) { ... } else { ... }
switch (status) {
  case Status.active: ...
  default: ...
}
for (final item in list) { ... }
list.where((e) => e > 1).map((e) => e * 2).toList();

Async

Future<int> fetch() async {
  final data = await api.get('/data');
  return data.length;
}
final value = await fetch();
try { await fetch(); } catch (e) { print(e); }
Stream<int> counter() async* { for (var i = 0; i < 3; i++) { yield i; } }

Null-safety

String? name;
final len = name?.length ?? 0;   // chaînage + fallback
name!;                           // force (à éviter)

---

Section 7 — Cheat sheet Flutter

Widgets de base

Text('Bonjour', style: TextStyle(fontSize: 18)),
Icon(Icons.favorite, color: Colors.red),
Image.network('https://...'),
ElevatedButton(onPressed: () {}, child: Text('OK')),
TextField(controller: controller),

Layouts

Column(
  crossAxisAlignment: CrossAxisAlignment.start,
  children: [ Text('A'), const SizedBox(height: 8), Text('B') ],
),
Row(mainAxisAlignment: MainAxisAlignment.spaceBetween, children: [...]),
Stack(children: [ base, Positioned(right: 0, top: 0, child: badge) ]),

Listes

ListView.builder(
  itemCount: items.length,
  itemBuilder: (context, index) => ListTile(title: Text(items[index])),
)
GridView.count(crossAxisCount: 2, children: [...])

État

class MyWidget extends StatefulWidget { ... }
class _MyWidgetState extends State<MyWidget> {
  int count = 0;
  void _inc() => setState(() => count++);
  @override
  Widget build(BuildContext context) { return ...; }
}

Thème

MaterialApp(
  theme: ThemeData(colorScheme: ColorScheme.fromSeed(seedColor: Colors.teal)),
  darkTheme: ThemeData(...brightness: Brightness.dark),
  home: const HomeScreen(),
)

Navigation

Navigator.push(context, MaterialPageRoute(builder: (_) => const Detail()));
Navigator.pop(context);

---

Section 8 — Cheat sheet React Native

Hooks

const [count, setCount] = useState(0);
useEffect(() => {
  fetchData();
  return () => cleanup();   // cleanup au démontage
}, [deps]);

const memoized = useMemo(() => compute(a, b), [a, b]);
const handler = useCallback(() => doThing(), [deps]);

Composants

<View style={{ flex: 1, justifyContent: 'center' }}>
  <Text style={styles.title}>Bonjour</Text>
  <Pressable onPress={() => setCount(c => c + 1)}>
    <Text>+</Text>
  </Pressable>
</View>

Listes

<FlatList
  data={items}
  keyExtractor={(item) => item.id}
  renderItem={({ item }) => <Item item={item} />}
  getItemLayout={...}
/>

Style

const styles = StyleSheet.create({
  title: { fontSize: 20, fontWeight: 'bold', color: '#333' },
});

Navigation (React Navigation)

<NavigationContainer>
  <Stack.Navigator>
    <Stack.Screen name="Home" component={HomeScreen} />
  </Stack.Navigator>
</NavigationContainer>
navigation.navigate('Detail', { id });

Réseau

const res = await fetch(url, { method: 'GET' });
const data = await res.json();

---

Section 9 — Design patterns mobile

9.1 Patterns de création

9.2 Patterns de structure

9.3 Patterns de comportement

9.4 Patterns d'architecture mobile

9.5 Patterns de performance

9.6 Anti-patterns à éviter

---

Synthèse

1. Glossaire : 205 termes couvrant langages, plateformes, architecture, data, réseau, tests, DevOps, sécurité.
2. Cheat sheets : 7 références rapides pour Kotlin, Swift, Compose, SwiftUI, Dart, Flutter, RN.
3. Patterns : création, structure, comportement, architecture, performance — avec leurs usages mobiles.

Pour aller plus loin

1. Imprimez ou gardez les cheat sheets ouvertes pendant vos exercices du chapitre 19.
2. Pour chaque pattern, trouvez un exemple réel dans vos projets (ou dans Now in Android).
3. Complétez le glossaire avec vos propres termes rencontrés en production.