# Android(2)-Première application
**Travail réalisé** :
Nous avons développé une application Android simple permettant d'interagir avec des composants graphiques (ex. : champs de texte, boutons) et d'explorer le cycle de vie d'une activité. Les fonctionnalités incluent la récupération de données saisies et leur affichage dans l'interface utilisateur.
**Difficultés rencontrées** :
- La compréhension du cycle de vie des activités Android.
----------
## Notion d'activité et ses fichiers essentiels
### Notion d'activité
Une **activité** représente un écran avec lequel l'utilisateur peut interagir. Elle est au cœur de toute application Android et gère l'affichage, la logique métier et les interactions utilisateur.
### Fichiers essentiels
1. **Fichier Java de l'activité** :
C'est la classe qui hérite de `AppCompatActivity`. Elle contient la logique métier et gère les interactions utilisateur.
2. **Fichier XML de mise en page** :
Définit l'interface graphique de l'activité (ex. : boutons, champs de texte). Il se trouve dans le dossier `res/layout` et est lié à l'activité Java via `setContentView(R.layout.nom_du_fichier)`.
----------
## Intérêt des fichiers de ressources (`strings.xml`, `colors.xml`)
### `strings.xml`
- Centralise les chaînes de caractères utilisées dans l'application.
- Facilite la gestion des textes pour la traduction et la maintenance.
- Exemple :
```xml
Bienvenue
```
### `colors.xml`
- Définit les couleurs utilisées dans l'application, assurant une cohérence visuelle.
- Exemple :
```xml
#FF5722
```
Ces fichiers permettent de séparer le contenu statique du code métier, rendant l'application plus lisible et modulaire.
----------
## Création des composants de l'interface graphique
1. **Ajout dans le fichier XML** :
Exemple d’un bouton :
```xml
```
2. **Liaison dans l’activité Java** :
```java
Button buttonValider = findViewById(R.id.buttonValider);
```
----------
## Méthode exécutée au lancement de l'activité
La méthode exécutée systématiquement est **`onCreate(Bundle savedInstanceState)`**.
Elle initialise l’activité et charge l’interface graphique définie dans le fichier XML via `setContentView`.
----------
## Rendre les objets graphiques accessibles dans le programme Java
Les objets graphiques définis dans le fichier XML sont accessibles en Java grâce à la méthode **`findViewById`**.
Exemple :
```java
EditText etPrenom = findViewById(R.id.etPrenom);
```
----------
## Récupération du contenu d’un champ saisi
Pour récupérer le texte saisi dans un champ `EditText` :
```java
String prenom = etPrenom.getText().toString();
```
----------
## Affichage d’un texte dans un contrôle graphique
Pour afficher du texte dans un `TextView` :
```java
TextView tvMessage = findViewById(R.id.tvMessage);
tvMessage.setText("Bonjour !");
```
----------
## Signification de `R` dans l’instruction
```java
etPrenom = (EditText) findViewById(R.id.etPrenom);
```
`R` est une classe générée automatiquement par Android qui référence toutes les ressources de l’application (fichiers XML, images, chaînes de caractères, etc.).
- `R.id.etPrenom` identifie l’élément graphique ayant l’attribut `android:id="@+id/etPrenom"` dans le fichier XML.
----------
## Pourquoi préciser le type de contrôle devant `findViewById` ?
`findViewById` retourne un objet générique de type `View`. Pour accéder aux méthodes spécifiques d’un contrôle graphique (`EditText`, `Button`, etc.), une conversion explicite (cast) est nécessaire.
----------
## Qu’est-ce qu’un Toast ?
Un **Toast** est un message temporaire affiché à l’écran pour notifier l’utilisateur.
Exemple d’affichage d’un Toast :
```java
Toast.makeText(getApplicationContext(), "Action réussie", Toast.LENGTH_SHORT).show();
```
----------
Ce document présente les concepts de manière claire et concise, avec des exemples pour appuyer les explications.
# **# Android(3) : Application avec appel de sous-activités**
#### **Contexte**
Une entreprise souhaite disposer d'une application mobile Android pour gérer son inventaire. Cette application, nommée _Inventaire_, permet aux salariés :
- D’ajouter un article au stock
- De visualiser les articles déjà ajoutés
- De quitter l’application temporairement
L’objectif est de créer une interface intuitive en utilisant plusieurs activités et d’assurer une navigation fluide entre celles-ci grâce aux _intents_.
----------
#### **Travail réalisé**
**Fenêtre principale (MainActivity)**
- Une interface avec trois boutons :
- **Ajouter un nouvel article** : ouvre la fenêtre _AjoutArticleActivity_.
- **Liste des articles** : ouvre la fenêtre _ListeArticleActivity_.
- **Quitter** : ferme l’interface en gardant l’application en arrière-plan.
**Fonctionnalités mises en place :**
1. **Création du projet** avec une activité principale (_Empty View Activity_).
2. **Interface graphique** de la fenêtre principale (LinearLayout vertical, TextView pour le titre, trois boutons avec libellés déclarés dans `strings.xml`).
3. **Bouton Quitter fonctionnel** : Utilisation de `finish()` pour quitter la fenêtre actuelle tout en conservant l'application active dans la liste des tâches.
4. **Lien entre les activités** grâce aux _intents_.
**Fenêtre AjoutArticle (AjoutArticleActivity)**
- Interface comprenant :
- Quatre champs de texte pour saisir :
- Référence
- Désignation
- Prix (réel)
- Quantité (entier)
- Un bouton "Ajouter".
- Un bouton "Quitter" qui retourne à la fenêtre principale.
- Utilisation d’un _intent_ pour la navigation depuis la fenêtre principale.
**Fenêtre Liste des articles (ListeArticleActivity)**
- Interface simple avec :
- Un titre ("Liste des articles").
- Un bouton "Quitter" pour revenir à la fenêtre principale.
- Gestion du retour avec l'utilisation d’un _intent_.
----------
#### **Explications techniques**
**Passage d'une activité à une autre**
La navigation entre les activités dans Android s’effectue via les _intents_.
Voici les étapes pour passer de la _MainActivity_ à une autre activité :
1. **Déclaration de l’activité cible** dans le fichier `AndroidManifest.xml`.
```xml
```
2. **Création d’un _intent_ dans le code de l’activité source**.
Exemple pour ouvrir _AjoutArticleActivity_ :
```java
Intent intent = new Intent(MainActivity.this, AjoutArticleActivity.class);
startActivity(intent);
```
3. **Ajout d’un gestionnaire d’événements sur le bouton** pour déclencher l’intent :
```java
btQuitter.setOnClickListener(new View.OnClickListener() {
});
```
----------
**Quitter une activité et revenir en arrière**
Pour quitter une activité, on utilise `finish()` :
- Cela termine l’activité actuelle et revient à celle qui l’a appelée.
- Exemple dans _AjoutArticleActivity_ :
```java
btQuitter.setOnClickListener(new View.OnClickListener() {
public void onClick(View arg0) {
finish();
}
});
```
----------
**Passage de données entre activités**
Pour transmettre des informations d’une activité à une autre, on utilise les extras des _intents_.
1. **Ajouter des données à l’intent** dans l’activité source :
```java
Intent intent = new Intent(MainActivity.this, AjoutArticleActivity.class);
intent.putExtra("EXTRA_REFERENCE", "Ref12345");
startActivity(intent);
```
2. **Récupérer les données dans l’activité cible** :
```java
Intent intent = getIntent();
String reference = intent.getStringExtra("EXTRA_REFERENCE");
```
3. **Retourner des résultats à l’activité appelante** :
On utilise `setResult()` et `onActivityResult()`.
Exemple pour envoyer une confirmation depuis _AjoutArticleActivity_ :
```java
Intent resultIntent = new Intent();
resultIntent.putExtra("ARTICLE_ADDED", true);
setResult(RESULT_OK, resultIntent);
finish();
```
Dans _MainActivity_, gérer la réponse :
```java
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_CODE_AJOUT && resultCode == RESULT_OK) {
boolean isAdded = data.getBooleanExtra("ARTICLE_ADDED", false);
if (isAdded) {
Toast.makeText(this, "Article ajouté avec succès", Toast.LENGTH_SHORT).show();
}
}
}
```
---
# Android(4) : Gestion des données avec SQLite
## **1. Présenter brièvement le travail à effectuer**
Le travail consiste à développer une base de données SQLite pour gérer les articles dans une application Android. Cela inclut la création des tables, la définition des relations entre les données, et l’implémentation des fonctionnalités pour ajouter, consulter, modifier et supprimer des articles. Une attention particulière doit être portée à la gestion de la version de la base et aux bonnes pratiques de programmation.
----------
## **2. Les 3 classes permettant la gestion de la base de données et leur rôle**
### **2.1. CreateBdInventaire**
- **Rôle** : Crée et gère la structure de la base de données (tables, colonnes).
- **Détails** :
- Méthode `onCreate` : Crée les tables nécessaires si la base n’existe pas.
- Méthode `onUpgrade` : Gère les modifications de structure en cas de changement de version.
### **2.2. DAO**
- **Rôle** : Fournit les méthodes de base pour ouvrir et fermer la connexion à la base de données.
- **Détails** :
- Méthode `open` : Ouvre la base en mode lecture/écriture.
- Méthode `close` : Ferme la connexion pour libérer les ressources.
### **2.3. ArticleDAO**
- **Rôle** : Implémente les opérations CRUD (Create, Read, Update, Delete) pour la table `article`.
- **Détails** :
- Méthode `create` : Insère un nouvel article dans la base.
- Méthode `read` : Récupère un ou plusieurs articles.
- Méthode `update` : Modifie un article existant.
- Méthode `delete` : Supprime un article.
----------
## **3. Quand la base de données est-elle créée ?**
La base de données est créée dans les situations suivantes :
- Lors du **premier lancement de l'application**, si aucune base portant le même nom n'existe sur le système.
- Lors d’un **changement de version** de la base, si la méthode `onUpgrade` est correctement implémentée.
----------
## **4. Tester le changement de version et copier l'affichage de la console Logcat**
### Étapes de test :
1. Augmenter la variable `VERSION_BDD` dans la classe `DAO`.
2. Ajouter une instruction `Log.d("bdd", "Base mise à jour")` dans la méthode `onUpgrade`.
3. Relancer l’application.
### Affichage Logcat :
```
2024-12-02 16:34:35.818 11716-11716 bdd com.example.manageinventory D Appel au constructeur de la DAO ok
2024-12-02 16:34:35.819 11716-11716 bdd com.example.manageinventory D Base de donnée ouverte
2024-12-02 16:34:44.857 11716-11716 bdd com.example.manageinventory D insert com.example.manageinventory.Article@46309a7
2024-12-02 16:34:46.611 11716-11716 bdd com.example.manageinventory D Base de donnée fermer
```
----------
## **5. Caractéristiques d’une base SQLite implémentée sur un smartphone**
SQLite est parfaitement adapté aux smartphones grâce à ses caractéristiques suivantes :
- **Léger** : Les bases sont stockées dans un simple fichier avec un minimum d’espace requis.
- **Portable** : Compatible avec toutes les versions d’Android et indépendant de l’architecture matérielle.
- **Performant** : Optimisé pour les lectures/écritures fréquentes et les transactions ACID.
- **Sans configuration** : Ne nécessite pas de serveur ou de processus séparé.
- **Support de SQL standard** : Permet d’utiliser des requêtes complexes pour manipuler les données.
----------
## **6. Ajouter une table `categorie` et la relier à la table `article`**
### Étapes pour ajouter la table `categorie` :
1. Modifier la méthode `onCreate` dans `CreateBdInventaire` pour inclure la création de la table `categorie` :
```sql
CREATE TABLE categorie (
id INTEGER PRIMARY KEY AUTOINCREMENT,
libelle TEXT NOT NULL
);
```
2. Ajouter une colonne `idCatego` dans la table `article` pour représenter la clé étrangère :
```sql
ALTER TABLE article ADD COLUMN idCatego INTEGER;
```
3. Définir une relation entre `article` et `categorie` :
```sql
CREATE TABLE article (
id INTEGER PRIMARY KEY AUTOINCREMENT,
ref TEXT NOT NULL,
des TEXT NOT NULL,
pu REAL,
qte INTEGER,
idCatego INTEGER,
FOREIGN KEY (idCatego) REFERENCES categorie(id)
);
```