1.
Structure d’un projet sur Android Studio
ggdd
Un projet Android Studio suit une structure organisée en plusieurs dossiers et fichiers :
app/ : Contient tout le code et les ressources de l'application.
o src/main/java/ : Contient le code source Java/Kotlin des activités,
fragments, et autres composants.
o res/ : Contient les ressources comme les layouts XML, les images, les fichiers
de valeurs ([Link], [Link]).
o [Link] : Fichier de configuration où sont définis les activités,
permissions, et autres composants.
build/ : Contient les fichiers générés automatiquement lors de la compilation.
gradle/ : Fichiers de configuration pour gérer les dépendances et le processus de
build.
.idea/ : Configurations spécifiques à Android Studio pour le projet.
2. Définir les mots-clés :
AVD (Android Virtual Device)
Un émulateur qui permet de simuler différents appareils Android (téléphone, tablette, montre,
etc.) pour tester une application sans avoir un appareil physique.
SDK (Software Development Kit)
Ensemble d'outils et de bibliothèques nécessaires pour développer des applications Android. Il
inclut les API, un compilateur, et des outils comme adb (Android Debug Bridge).
Android Studio : est l'environnement de développement intégré (IDE) officiel pour Android,
basé sur IntelliJ IDEA. Il fournit des outils pour développer, tester, et déployer des
applications Android. Il prend en charge Kotlin, Java, et C++ pour le développement natif.
Activity : est un composant de base d'une application Android. Elle représente une seule
interface utilisateur avec laquelle l'utilisateur peut interagir.
View : Un composant graphique unique, comme un bouton, une image, ou un texte.
Layout : définit la structure de l'interface utilisateur d'une activité ou d'un fragment.
API Android : permet aux développeurs d'accéder aux fonctionnalités du système. Par
exemple :
Camera API : Pour accéder à l'appareil photo.
Location API : Pour obtenir la position GPS.
Media API : Pour gérer les fichiers multimédias.
APK (Android Package Kit) : est le fichier binaire utilisé pour installer une application sur
un appareil Android.
4. Décrire techniquement les mots-clés
Drawable : C'est un dossier dans le répertoire res/ qui contient des ressources graphiques
(images, formes, icônes). Il peut inclure des fichiers .png, .jpg, ou des XML définissant des
formes ou des animations.
AVD (Android Virtual Device) : Permet de simuler des appareils Android pour tester
l'apparence et les fonctionnalités des applications sur différents écrans, versions, ou
résolutions.
EditText : Un composant graphique qui permet à l’utilisateur de saisir des données textuelles
dans une application (comme un champ de formulaire ou un mot de passe).
5. Utilité du langage XML dans un projet Android
XML est utilisé pour séparer la présentation interface utilisateur (UI) de la logique (Java/Kotlin),
rendant l'application plus facile à gérer, à modifier et à maintenir.
Le langage XML est utilisé pour :
1. Définir les interfaces utilisateur : Organisation des layouts des écrans avec des
composants comme TextView, Button, etc.
2. Stocker des ressources : Valeurs réutilisables comme les chaînes de caractères
([Link]), les couleurs ([Link]), ou les dimensions ([Link]).
3. Configuration : Fichier [Link] pour configurer les composants de
l’application.
Avantage :
Lisibilité et séparation du code (interface et logique métier).
Réutilisation facile des éléments.
I. Les étapes pour la création du Spinner :
1. Ajouter un widget Spinner dans le layout.
2. Code :
String[] Amis = {"a", "b", "c", "d", "e", "f", "g", "h"};
Spinner spinner1;
spinner1 = findViewById([Link]);
ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
[Link].simple_spinner_dropdown_item, Amis);
[Link](adapter);
// Set up Item Selected Listener
[Link](new [Link]()
{
@Override
public void onItemSelected(AdapterView<?> parent, View view, int
position, long id) {
[Link](getApplicationContext(), Amis[position],
Toast.LENGTH_SHORT).show();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
// Do nothing
}
});
II. Les étapes pour la création du ListView :
1. Ajouter un widget ListView dans le layout.
2. Code :
String[] Amis = {"a", "b", "c", "d", "e", "f", "g", "h"};
ListView list1;
list1 = findViewById([Link]);
[Link](new ArrayAdapter<String>(this,
[Link].simple_expandable_list_item_1, Amis));
III. Les étapes pour la création du GridView :
1. Ajouter un widget GridView dans le layout.
2. Code :
String[] Amis = {"a", "b", "c", "d", "e", "f", "g", "h"};
GridView gridView;
gridView = findViewById([Link]);
ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
[Link].simple_list_item_1, Amis);
[Link](adapter);
IV. Les étapes pour afficher une liste avec des images dans GridView :
1. Ajouter un widget GridView dans le layout.
2. Ajouter les images dans le dossier res/drawable.
3. Dans res/layout/list_item.xml, créer un layout pour chaque élément de la liste.
4. Code :
ListView listView;
String[] noms = {"Élément 1", "Élément 2", "Élément 3"};
int[] images = {[Link].image1, [Link].image2, [Link].image3};
listView = findViewById([Link]);
ArrayList<HashMap<String, Object>> data = new ArrayList<>();
for (int i = 0; i < [Link]; i++) {
HashMap<String, Object> map = new HashMap<>();
[Link]("image", images[i]); // Associer l'image
[Link]("nom", noms[i]); // Associer le texte
[Link](map);
}
String[] from = {"image", "nom"};
int[] to = {[Link], [Link]};
SimpleAdapter adapter = new SimpleAdapter(this, data, [Link].list_item,
from, to);
[Link](adapter);
V. Les étapes pour la création du Splash Screen :
1. S'assurer d'activer SplashActivity en tant que Launcher Activity dans le
[Link].
2. Créer un layout splash_screen.xml (contenant une image/logo).
3. Définir SplashActivity comme écran de lancement.
4. Ajouter un délai avec [Link]().
5. Rediriger vers l’Activity principale après le délai.
6. Code :
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
startActivity(new Intent([Link], [Link]));
finish();
}
}, 2000); // 2000 ms = 2 secondes
VI. Étapes pour créer un menu dans Android Native :
1. Créer un fichier de menu XML dans le répertoire res/menu (ex: menu_main.xml).
2. Définir les éléments du menu dans le fichier XML en utilisant des balises <item>.
3. Gérer le menu dans l'Activity en surchargeant la méthode onCreateOptionsMenu().
4. Gérer les clics sur les éléments du menu en surchargeant la méthode
onOptionsItemSelected().
5. Associer le menu à l'Activity en déclarant l'élément menu dans
onCreateOptionsMenu().
6. Code :
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate([Link].menu_main, menu);
return true;
}
VII. Étapes pour utiliser SimpleAdapter avec CardView :
1. Créer un layout XML pour chaque élément de la CardView.
2. Définir les données à afficher dans le CardView sous forme de liste de Map<String,
Object>.
3. Utiliser SimpleAdapter pour lier les données au ListView ou GridView.
4. Personnaliser le layout de chaque élément pour inclure un CardView.
5. Code :
List<Map<String, Object>> data = new ArrayList<>();
String[] titles = {"Title 1", "Title 2", "Title 3"};
int[] images = {[Link].image1, [Link].image2, [Link].image3};
for (int i = 0; i < [Link]; i++) {
Map<String, Object> map = new HashMap<>();
[Link]("title", titles[i]);
[Link]("image", images[i]);
[Link](map);
}
ListView listView = findViewById([Link]);
SimpleAdapter adapter = new SimpleAdapter(
this,
data,
[Link].item_card, // Le layout pour chaque CardView
new String[]{"title", "image"}, // Les clés des données
new int[]{[Link].card_title, [Link].card_image} // Les ID des éléments dans
item_card.xml
);
[Link](adapter);
