ASPECTS AVANCES DE LA PROGRAMMATION MOBILE

Interface adaptative : Responsive

L'adaptabilité de l'interface utilisateur est essentielle pour garantir une expérience

utilisateur optimale sur une grande variété d'appareils et de tailles d'écran. Dans
Flutter, vous pouvez créer des interfaces utilisateur réactives qui s'ajustent
dynamiquement en fonction de la taille de l'écran et d'autres facteurs. Voici
comment :

Media Query

Flutter fournit la classe MediaQuery, qui vous permet d'interroger les propriétés
de l'appareil, telles que la taille de l'écran, l'orientation et la densité de pixels. Vous
pouvez utiliser MediaQuery pour rendre votre interface utilisateur réactive en
fonction de ces propriétés.

Copy

Widget build(BuildContext context) {

final Size screenSize = MediaQuery.of(context).size;

final double screenWidth = screenSize.width;

final double screenHeight = screenSize.height;

// Utiliser la taille de l'écran pour rendre l'interface utilisateur réactive

return Container(

width: screenWidth * 0.8, // Utiliser 80% de la largeur de l'écran

 height: screenHeight * 0.6, // Utiliser 60% de la hauteur de l'écran

child: // Votre contenu ici

);

LayoutBuilder

La classe LayoutBuilder vous permet de créer des interfaces utilisateur réactives

en fonction des contraintes de mise en page actuelles. Vous pouvez utiliser
LayoutBuilder pour ajuster dynamiquement la mise en page en fonction de la
taille de l'écran.

Copy

Widget build(BuildContext context) {

return LayoutBuilder(

builder: (BuildContext context, BoxConstraints constraints) {

final double maxWidth = constraints.maxWidth;

final double maxHeight = constraints.maxHeight;

// Utiliser les contraintes de mise en page pour rendre l'interface utilisateur

réactive

return Container(

width: maxWidth * 0.8, // Utiliser 80% de la largeur disponible

height: maxHeight * 0.6, // Utiliser 60% de la hauteur disponible

 child: // Votre contenu ici

);

},

);

MediaQuery.of(context).orientation

Vous pouvez également utiliser la propriété orientation de MediaQuery pour

adapter l'interface utilisateur en fonction de l'orientation de l'appareil.

Copy

final Orientation orientation = MediaQuery.of(context).orientation;

if (orientation == Orientation.portrait) {

// Afficher une mise en page adaptée à la vue portrait

} else {

// Afficher une mise en page adaptée à la vue paysage

En utilisant ces techniques, vous pouvez créer des interfaces utilisateur réactives
qui s'adaptent dynamiquement à différentes tailles d'écran et orientations, offrant
ainsi une expérience utilisateur cohérente sur tous les appareils.

JSON (JavaScript Object Notation)

Manipulation des données JSON

En Dart, le package dart:convert fournit des outils pour convertir des objets Dart
en format JSON (JavaScript Object Notation) et vice versa. Cela est utile pour
échanger des données avec des services web ou des fichiers qui utilisent le format
JSON.

Convertir un objet en JSON

Utilisez la méthode jsonEncode du package dart:convert pour convertir un objet

Dart en JSON :

Copy

import 'dart:convert';

void main() {

Map<String, dynamic> person = {

'name': 'Alice',

'age': 30,

'isEmployed': true,

};

String jsonPerson = jsonEncode(person);

print(jsonPerson);

}
Dans cet exemple, un objet person est converti en une chaîne JSON à l'aide de
jsonEncode.

Convertir du JSON en objet

Utilisez la méthode jsonDecode du package dart:convert pour convertir une

chaîne JSON en un objet Dart :

Copy

import 'dart:convert';

void main() {

String jsonPerson = '{"name": "Alice", "age": 30, "isEmployed": true}';

Map<String, dynamic> person = jsonDecode(jsonPerson);

print('Name: ${person['name']}');

print('Age: ${person['age']}');

print('Is Employed: ${person['isEmployed']}');

Dans cet exemple, la chaîne JSON jsonPerson est convertie en un objet Dart
person à l'aide de jsonDecode.

Gérer des données complexes

Pour gérer des données JSON complexes, vous pouvez utiliser des classes Dart
qui représentent la structure des données JSON. Voici un exemple :

Copy

import 'dart:convert';

class Person {

String name;

int age;

bool isEmployed;

Person({required this.name, required this.age, required this.isEmployed});

factory Person.fromJson(Map<String, dynamic> json) {

return Person(

name: json['name'],

age: json['age'],

isEmployed: json['isEmployed'],

);

}
 Map<String, dynamic> toJson() {

return {

'name': name,

'age': age,

'isEmployed': isEmployed,

};

void main() {

String jsonPerson = '{"name": "Alice", "age": 30, "isEmployed": true}';

Map<String, dynamic> jsonData = jsonDecode(jsonPerson);

Person person = Person.fromJson(jsonData);

print('Name: ${person.name}');

print('Age: ${person.age}');

print('Is Employed: ${person.isEmployed}');

Dans cet exemple, la classe Person est utilisée pour représenter la structure des
données JSON et pour convertir les données JSON en objets Dart et vice versa.

API-Dépendance : Ajout de plugins ou de bibliothèques externe

L'ajout de plugins ou de bibliothèques externes à votre application Flutter est une
étape importante pour étendre ses fonctionnalités et intégrer des fonctionnalités
prêtes à l'emploi. Voici comment intégrer des dépendances à votre application et
découvrir des packages sur pub.dev :

Découvrir pub.dev

pub.dev est le répertoire officiel des packages pour Flutter et Dart. Vous pouvez
rechercher des packages par mots-clés, par popularité ou par catégorie. Voici
comment vous pouvez découvrir de nouveaux packages :

Recherche par mots-clés : Utilisez la barre de recherche pour rechercher des

packages en fonction de mots-clés pertinents pour votre application.

Exploration par catégorie : Parcourez les différentes catégories telles que UI,
Networking, State Management, etc., pour trouver des packages correspondant à
vos besoins.

Filtrage par popularité : Consultez les packages les plus populaires sur pub.dev
pour découvrir ceux qui sont largement utilisés et bien entretenus par la
communauté Flutter.

Lecture de la documentation
Avant d'intégrer un package à votre application, il est important de lire sa
documentation pour comprendre comment l'utiliser correctement. Voici ce que
vous devriez rechercher dans la documentation d'un package :

Installation : Consultez les instructions d'installation du package pour savoir

comment l'intégrer à votre projet Flutter.

Utilisation : Explorez les exemples de code et les guides d'utilisation pour

apprendre comment utiliser les fonctionnalités fournies par le package.

Configuration : Si le package nécessite une configuration spécifique, assurez-vous

de suivre les instructions fournies dans la documentation.

Support : Vérifiez s'il existe des canaux de support, tels que GitHub issues ou un
canal Discord, où vous pouvez poser des questions ou signaler des problèmes.

Exemple d'intégration de package

Voici un exemple d'intégration d'un package externe dans votre application Flutter
en utilisant le fichier pubspec.yaml :

Copy

dependencies:

flutter:
 sdk: flutter

http: ^0.14.0 # Exemple d'intégration du package HTTP pour les requêtes HTTP

Dans cet exemple, le package HTTP est ajouté comme dépendance à l'application
Flutter. Après avoir modifié le fichier pubspec.yaml, vous pouvez exécuter flutter
pub get dans votre terminal pour installer le package.

Intégrer des dépendances externes à votre application Flutter est une étape
cruciale pour étendre ses fonctionnalités et bénéficier de la richesse de
l'écosystème Flutter.

SQLite

SQLite est une base de données relationnelle légère et efficace, souvent utilisée
pour stocker des données localement dans les applications mobiles. Voici
comment intégrer SQLite à votre application Flutter :

Installation du plugin : Utilisez le plugin sqflite pour intégrer SQLite à votre

application Flutter. Ajoutez-le à votre fichier pubspec.yaml comme ceci :

Copy

dependencies:

flutter:

sdk: flutter

sqflite: ^2.0.0
Utilisation du plugin : Importez le package sqflite dans votre fichier Dart et
commencez à utiliser les fonctionnalités de SQLite. Voici un exemple simple de
création d'une base de données et d'une table :

Copy

import 'package:sqflite/sqflite.dart';

import 'package:path/path.dart';

void main() async {

// Ouverture de la base de données (ou création si elle n'existe pas)

var database = await openDatabase(

join(await getDatabasesPath(), 'my_database.db'),

onCreate: (db, version) {

return db.execute(

'CREATE TABLE users(id INTEGER PRIMARY KEY, name TEXT, age

INTEGER)',

);

},

version: 1,

);

// Insertion de données

await database.insert(
 'users',

{'name': 'Alice', 'age': 30},

conflictAlgorithm: ConflictAlgorithm.replace,

);

// Récupération des données

List<Map<String, dynamic>> users = await database.query('users');

// Affichage des données

print(users);

Dans cet exemple, une base de données SQLite est créée avec une table users. Des
données sont insérées dans la table et récupérées ensuite.

Lecture de la documentation : Assurez-vous de lire la documentation complète du

plugin sqflite pour comprendre toutes ses fonctionnalités et les meilleures
pratiques pour son utilisation. Vous pouvez trouver la documentation sur pub.dev.

L'intégration de SQLite à votre application Flutter vous permet de stocker et de

gérer efficacement des données localement, ce qui est utile pour de nombreuses
applications mobiles.

Exemple de service
Pour créer un service qui gère la base de données SQLite avec une table Person,
vous pouvez suivre les étapes suivantes :

Créez une classe DatabaseService qui gère l'accès à la base de données SQLite et
les opérations CRUD (Create, Read, Update, Delete) pour la table Person.

Initialisez la base de données et la table Person lors de la première utilisation du

service.

Implémentez des méthodes pour ajouter, lire, mettre à jour et supprimer des
enregistrements de la table Person.

Voici un exemple de service DatabaseService :

Copy

import 'package:sqflite/sqflite.dart';

import 'package:path/path.dart';

class DatabaseService {

static Database? _database;

static const String _tableName = 'persons';

Future<void> _initDatabase() async {

 if (_database == null) {

_database = await openDatabase(

join(await getDatabasesPath(), 'persons_database.db'),

onCreate: (db, version) {

return db.execute(

'CREATE TABLE $_tableName(id INTEGER PRIMARY KEY, name

TEXT, age INTEGER)',

);

},

version: 1,

);

Future<void> insertPerson(Person person) async {

await _initDatabase();

await _database!.insert(

_tableName,

person.toMap(),

conflictAlgorithm: ConflictAlgorithm.replace,

);

}
 Future<List<Person>> getPersons() async {

await _initDatabase();

final List<Map<String, dynamic>> maps = await

_database!.query(_tableName);

return List.generate(maps.length, (i) {

return Person(

id: maps[i]['id'],

name: maps[i]['name'],

age: maps[i]['age'],

);

});

Future<void> updatePerson(Person person) async {

await _initDatabase();

await _database!.update(

_tableName,

person.toMap(),

where: 'id = ?',

whereArgs: [person.id],

);
 }

Future<void> deletePerson(int id) async {

await _initDatabase();

await _database!.delete(

_tableName,

where: 'id = ?',

whereArgs: [id],

);

class Person {

final int? id;

final String name;

final int age;

Person({this.id, required this.name, required this.age});

Map<String, dynamic> toMap() {

return {

'id': id,
 'name': name,

'age': age,

};

Dans cet exemple, la classe DatabaseService gère l'accès à la base de données

SQLite. Les méthodes insertPerson, getPersons, updatePerson et deletePerson
permettent respectivement d'ajouter, de récupérer, de mettre à jour et de supprimer
des enregistrements de la table persons. La classe Person représente un
enregistrement de la table avec les propriétés id, name et age.

HTTP: Communication Réseau

La communication réseau est essentielle pour de nombreuses applications

mobiles, permettant d'échanger des données avec des serveurs distants. Dans
Flutter, vous pouvez utiliser le package http pour effectuer des requêtes HTTP et
gérer les réponses. Voici comment vous pouvez l'utiliser pour différentes
méthodes HTTP :

Comprendre le Protocole HTTP

Le protocole HTTP (Hypertext Transfer Protocol) est un protocole de

communication utilisé pour transférer des données sur le Web. Il utilise une
architecture client-serveur où le client envoie une requête au serveur, qui répond
avec une réponse.
Méthode GET

La méthode GET est utilisée pour demander des données à partir d'une ressource
spécifiée. Par exemple, pour récupérer des données à partir d'une API, vous
pouvez utiliser la méthode GET :

Copy

import 'package:http/http.dart' as http;

Future<void> fetchData() async {

var response = await http.get(Uri.parse('https://example.com/api/data'));

if (response.statusCode == 200) {

// Traitement des données de réponse

} else {

// Gestion des erreurs

Méthode POST

La méthode POST est utilisée pour soumettre des données à une ressource
spécifiée, souvent utilisée pour créer de nouvelles entrées. Par exemple, pour
envoyer des données à une API, vous pouvez utiliser la méthode POST :
Copy

Future<void> createData() async {

var response = await http.post(

Uri.parse('https://example.com/api/data'),

body: {'key': 'value'},

);

if (response.statusCode == 201) {

// Traitement des données de réponse

} else {

// Gestion des erreurs

Méthode PUT

La méthode PUT est utilisée pour mettre à jour des données sur le serveur. Par
exemple, pour mettre à jour des données sur une API, vous pouvez utiliser la
méthode PUT :

Copy

Future<void> updateData() async {

var response = await http.put(

Uri.parse('https://example.com/api/data/1'),
 body: {'key': 'updated_value'},

);

if (response.statusCode == 200) {

// Traitement des données de réponse

} else {

// Gestion des erreurs

Méthode DELETE

La méthode DELETE est utilisée pour supprimer des données sur le serveur. Par
exemple, pour supprimer des données sur une API, vous pouvez utiliser la
méthode DELETE :

Copy

Future<void> deleteData() async {

var response = await http.delete(Uri.parse('https://example.com/api/data/1'));

if (response.statusCode == 204) {

// Succès de la suppression

} else {

// Gestion des erreurs

}
}

Gestion des Erreurs

Il est important de gérer les erreurs lors de l'envoi de requêtes HTTP. Vous pouvez
utiliser des blocs try/catch pour capturer les exceptions et gérer les erreurs de
manière appropriée.

Copy

try {

var response = await http.get(Uri.parse('https://example.com/api/data'));

if (response.statusCode == 200) {

// Traitement des données de réponse

} else {

// Gestion des erreurs HTTP

} catch (e) {

// Gestion des erreurs de connexion

En comprenant les différentes méthodes HTTP et en utilisant le package http de

manière appropriée, vous pouvez créer des applications Flutter qui communiquent
efficacement avec des serveurs distants et fournissent une expérience utilisateur
fluide.

Sécurité dans les Applications Flutter

La sécurité est une préoccupation majeure dans le développement d'applications
mobiles. Flutter offre des fonctionnalités intégrées pour sécuriser les données
sensibles et authentifier les utilisateurs de manière sécurisée. Voici quelques
techniques de sécurité couramment utilisées dans les applications Flutter :

1. Authentification par Login et Mot de Passe

L'authentification par login et mot de passe est la méthode d'authentification la

plus courante. Les utilisateurs doivent saisir leur identifiant (email, nom
d'utilisateur) et leur mot de passe pour accéder à l'application. Flutter propose des
packages tels que Firebase Authentication pour gérer facilement l'authentification
par login et mot de passe.

2. Authentification par Empreinte Digitale

L'authentification par empreinte digitale est une méthode de sécurité biométrique

qui utilise l'empreinte digitale d'un utilisateur pour vérifier son identité. Flutter
prend en charge l'authentification par empreinte digitale via le package
local_auth, permettant ainsi aux utilisateurs d'accéder à l'application en utilisant
leur empreinte digitale.

3. Authentification par Reconnaissance Faciale

L'authentification par reconnaissance faciale est une méthode de sécurité

biométrique qui utilise la reconnaissance faciale d'un utilisateur pour vérifier son
identité. Flutter prend en charge l'authentification par reconnaissance faciale via
le package local_auth, permettant aux utilisateurs d'accéder à l'application en
utilisant leur visage.

Bonnes Pratiques de Sécurité

Chiffrement des Données Sensibles : Utilisez le chiffrement pour protéger les

données sensibles, telles que les mots de passe et les informations financières.

Mises à Jour Régulières : Assurez-vous que votre application est toujours à jour
pour bénéficier des derniers correctifs de sécurité.

Validation des Entrées Utilisateurs : Validez toutes les entrées utilisateurs pour
prévenir les attaques par injection de code.

Gestion des Sessions : Gérez correctement les sessions utilisateur pour éviter les
accès non autorisés.

Audit de Sécurité : Effectuez régulièrement des audits de sécurité pour identifier

et corriger les vulnérabilités de sécurité.

En suivant ces bonnes pratiques de sécurité et en utilisant les fonctionnalités de

sécurité intégrées à Flutter, vous pouvez garantir que votre application est
sécurisée et protégée contre les menaces potentielles.