Université Ahmed Draia - Adrar
Faculté des Sciences de la Matière et Mathématiques et Informatique
Département de Mathématiques et Informatique
3 eme année Licence Informatique
Développement des applications mobiles
Chapitre 03 : Activités et ressources
2024 - 2025
Plan
[Link]
2. Notion d’activité
3. Cycle de vie d’une activité
4. Les ressources
5. Organisation des ressources
6. Utilisation des ressources
Les chaînes de caractère
Les drawables
Les animations
[Link]
Une application Android est constituée de composants faiblement couplés.
Ces composants sont décrits dans un même document : le Manifest, un fichier au
format XML « [Link] » qui décrit :
Chaque composant : Activities, Services, Content Providers, Broadcast Receivers ;
Les interactions de ces composants : Intent Filters et NotiĄcations ;
Les accès nécessaires au matériel et logiciel (bibliothèques) :Permissions
[Link]
Toute application doit contenir le fichier XML [Link]. Ce fichier déclare, les
différents composants de l'application. Ce fichier contient aussi :
• Les permissions nécessaires à l'application (accès internet).
• Le numéro minimum de la version API utilisée.
• Les logiciels et matériels utilisés par l'application (caméra).
• Bibliothèques supplémentaires à l'API de base (Google maps, library).
[Link]
Le fichier manifest
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=[Link] package="[Link]“ android:versionCode="1“ android:versionName="1.0">
<application android:icon="@drawable/icon“ android:label="@string/app_name">
<activity android:name=".Main“ android:label="@string/app_name">
<intent-filter>
<action android:name="[Link]" />
<category android:name="[Link]" />
</intent-filter>
</activity>
<service>...</service>
<receiver>...</receiver>
<provider>...</provider>
</application>
</manifest>
2. Notion d’activité
Une activité(activity):
• Une activité est la composante principale pour une application Android. Elle représente
l’implémentation métier dans une application Android, permettant de gérer l’ensemble des
vues et ressources.
• Elles représentent des interfaces individuelles ou des composants d'interface utilisateur
d'une application avec lesquels les utilisateurs peuvent interagir.
• Chaque activité a généralement un objectif ou une fonction spécifique, comme l'affichage
d'une liste d'éléments, la modification des informations de l'utilisateur ou la lecture d'une
vidéo.
• Les activités sont organisées et gérées par le système Android afin d'offrir à l'utilisateur une
expérience transparente.
2. Notion d’activité
Une activité(activity):
• Elle est démarrée à la demande de l’utilisateur ou du système[1].
• Elle tourne aussi longtemps qu'elle est utile: le système peut tuer une activité pour récupérer
de la mémoire.
• Elle peut interagir avec l’utilisateur, demander des données ou des services à d’autres
activités ou à des services, au travers de requetés et d’intentions (intents).
• En général, une activité = un écran d’interface, appelé View.
2. Notion d’activité
Squelette d’une activité
Une activité est une sous classe d’[Link].
2. Notion d’activité
Exemple d’une activité
package [Link];
import [Link];
import [Link];
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
setContentView([Link].activity_main);
}
}
2. Notion d’activité
Exemple d’une activité
Dans l’exemple précédent on importe deux classes qui se trouvent dans deux packages différents :
AppCompatActivity et Bundle.
AppCompatActivity est une classe qui décrit une activité supportant une barre d'action.
@Override permet d'indiquer une redéfinition de méthode à partir de la classe mère ( ici c’est
AppCompatActivity ).
La méthode onCreate() est la première qui est lancée au démarrage d'une application, mais elle est
aussi appelée après qu'une application se soit faite tuée par le système en manque
de mémoire!
2. Notion d’activité
Exemple d’une activité
Bundle est utile lorsque une activité est détruite puis recréée (voir le cycle de vie d'une activité).
C'est à cela que sert l'attribut de type Bundle :
• S'il s'agit du premier lancement de l'application ou d'un démarrage alors qu'elle avait été quittée
normalement, il vaut null.
• Mais s'il s'agit d'un retour à l'application après qu'elle a perdu le focus et a redémarré, alors il pourra
contenir un état sauvegardé de l'application que vous aurez pris soin de constituer. ( par exemple :
une chanson qui reprend à l'endroit où elle s'est arrêtée avant d'être interrompue par un appel).
L'instruction setContentView([Link].activity_main); permet d'affecter l'interface graphique à
l'activité (les rattacher) et qui est décrite dans le fichier activity_main.xml.
[Link] de vie d’une Activité
Dans Android, il n’y a qu’une activité(active) à la fois, c’est-à-dire , en avant plant.
Le système d’exploitation est libre de terminer une activité qui est en arrière plan, lorsque la
quantité de mémoire libre du système est trop basse. Ainsi, une application Android, lorsqu’elle
n’est plus en avant-plan, doit être capable de maintenir son état pour garantir un fonctionnement
seamless à l’utilisateur. C’est l’application qui gère sont état, ses donnes, et ses ressources afin
d’etre prête à être interrompue ou bien terminée à tout moment. Pour répondre à ses
évènements, des méthodes de réponse callback sont définies: onCreate(),OnStart(),
onResume(), onPause(),OnStop(), onDestroy().
Donc, le cycle de vie d'une activité Android comporte plusieurs étapes qui correspondent à
différents événements qui se produisent pendant l'exécution de l'activité .
[Link] de vie d’une Activité
onCreate()
Cette méthode est appelée lors de la création de l'activité. Elle est généralement utilisée pour
effectuer les tâches initiales de configuration de l'activité, telles que la configuration de l'interface
utilisateur, l'initialisation des variables ou le chargement des données à partir d'une base de données.
C'est également à ce moment-là que vous appelez setContentView() pour définir la mise en page de
l'activité. Afin de surcharger cette méthode, il suffit d'ajouter le code ci-dessous à votre classe d'activité
et d'implémenter la logique requise.
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple: Gérer les permissions: Vous pouvez demander des permissions à l'utilisateur lorsque
l'activité est créée ou reprise.
private static final int REQUEST_CODE_LOCATION_PERMISSION = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
setContentView([Link].activity_main);
// Vérifier et demander la permission
if ([Link](this, [Link].ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED) {
[Link](this,
new String[]{[Link].ACCESS_FINE_LOCATION},
REQUEST_CODE_LOCATION_PERMISSION);
}
}
[Link] de vie d’une Activité
onStart()
Cette méthode est appelée lorsque l'activité devient visible pour l'utilisateur. Elle est souvent utilisée
pour effectuer les tâches de configuration nécessaires qui doivent se produire lorsque l'activité est affichée pour
la première fois. Par exemple, vous pouvez utiliser cette méthode pour démarrer une animation ou vous
connecter à un service réseau. Pour surcharger cette méthode, ajoutez ce code à votre classe d'activité et mettez
en œuvre la logique requise.
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple:
Démarrer et arrêter des animations:
Vous pouvez démarrer une animation lorsque l'activité est visible et l'arrêter lorsqu'elle est en pause.
@Override
protected void onStart() {
[Link]();
// Démarrer une animation
ImageView imageView = findViewById([Link]);
Animation animation = [Link](this, [Link]);
[Link](animation);
Log.d("Lifecycle", "Animation démarrée");
}
[Link] de vie d’une Activité
onResume()
Cette méthode est appelée lorsque l'activité est au premier plan et qu'elle a le focus. Elle est
souvent utilisée pour reprendre les opérations qui ont été mises en pause dans onPause(), telles que le
démarrage d'animations, la lecture de médias ou la création de récepteurs pour les entrées de l'utilisateur.
C'est également à ce moment-là que l'on démarre les threads d'arrière-plan nécessaires à la mise à jour de
l'interface utilisateur ou à l'exécution d'autres tâches. Ajoutez ce code pour surcharger cette méthode.
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple:
Gérer les connexions réseau: Vous pouvez démarrer une connexion réseau lorsque l'activité est reprise et
l'arrêter lorsqu'elle est mise en pause.
@Override
protected void onResume() {
[Link]();
// Démarrer une connexion réseau
Log.d("Lifecycle", "Connexion réseau démarrée");
}
[Link] de vie d’une Activité
onPause()
Cette méthode est appelée lorsque l'activité perd le focus et n'est plus au premier plan. Elle est souvent utilisée
pour mettre en pause les opérations en cours qui doivent être arrêtées lorsque l'activité n'est plus visible, comme
l'arrêt des animations, la mise en pause de la lecture des médias ou la suppression des récepteurs d'entrée de
l'utilisateur. Ajoutez ce code pour surcharger cette méthode.
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple:
Gérer les ressources système
Vous pouvez libérer des ressources (comme des connexions réseau ou des capteurs) lorsque
l'activité est mise en pause ou arrêtée.
@Override
protected void onPause() {
[Link]();
// Libérer des ressources (ex : arrêter un capteur)
Log.d("Lifecycle", "Activity en pause - Libération des ressources");
}
@Override
protected void onResume() {
[Link]();
// Réacquérir des ressources (ex : redémarrer un capteur)
Log.d("Lifecycle", "Activity reprise - Acquisition des ressources");
}
[Link] de vie d’une Activité
onStop()
Cette méthode est appelée lorsque l'activité n'est plus visible par l'utilisateur. Elle est souvent utilisée pour
arrêter les threads ou les services d'arrière-plan qui ont été démarrés dans onStart(), ainsi que pour libérer les
ressources système qui ne sont plus nécessaires. Par exemple, vous pouvez utiliser cette méthode pour arrêter
un service réseau ou libérer une ressource caméra. Ajoutez ce code pour surcharger cette méthode:
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple:
Gérer les notifications:Vous pouvez afficher une notification lorsque l'activité est mise en arrière-plan
@Override
protected void onStop() {
[Link]();
// Afficher une notification
[Link] builder = new [Link](this,
"channel_id")
.setSmallIcon([Link].ic_notification)
.setContentTitle("Activité en arrière-plan")
.setContentText("L'application est toujours en cours d'exécution.")
.setPriority(NotificationCompat.PRIORITY_DEFAULT);
NotificationManagerCompat notificationManager =
[Link](this);
[Link](1, [Link]());
}
[Link] de vie d’une Activité
onRestart()
Cette méthode est appelée lorsque l'activité est redémarrée après avoir été arrêtée. Elle est
souvent utilisée pour effectuer les tâches de configuration nécessaires au redémarrage de
l'activité, telles que la réinitialisation de l'interface utilisateur ou le rechargement des données
d'une base de données. Ajoutez ce code pour surcharger cette méthode:
[Link] de vie d’une Activité
[Link] de vie d’une Activité
onDestroy()
Cette méthode est appelée lorsque l'activité est sur le point d'être détruite. Elle est souvent utilisée pour
libérer les ressources qui ne sont plus nécessaires, comme la fermeture des connexions à la base de
données ou l'arrêt des services d'arrière-plan. C'est également à ce moment-là que vous effectuez les
dernières tâches de nettoyage nécessaires avant la destruction de l'activité, comme la libération des
ressources système ou la destruction des récepteurs de diffusion. Ajoutez ce code pour surcharger cette
méthode:
[Link] de vie d’une Activité
[Link] de vie d’une Activité
Exemple:
Gérer les tâches asynchrones: Si vous utilisez des tâches asynchrones (comme `AsyncTask` ou
`Thread`), vous devez les gérer correctement pour éviter les fuites de mémoire.
@Override
protected void onDestroy() {
[Link]();
// Annuler la tâche asynchrone si l'activité est détruite
if (myAsyncTask != null) {
[Link](true);
}
Log.d("Lifecycle", "Tâche asynchrone annulée");
}
[Link] de vie d’une Activité
Le fichier ACTIVITY_MAIN.XML
Le fichier activity_main.xml généré est repéré par la constante [Link].activity_main, argument de
setContentView() dans l'activité. Son contenu peut être visualisé en mode Design ou Text (code)
(XML).
Ce fichier contient la description de l'IHM.
Souvent, l'IHM est construite par glisser-déposer sous l'onglet Design qui suggère :
les composants graphiques (Widgets)
les positionnements (Layouts)
[Link] ressources
Définition:
En développement Android, les ressources sont des fichiers statiques et des informations constantes
utilisées par l’application. Elles peuvent inclure des images, des fichiers XML, des chaînes de caractères,
des
. couleurs, des dimensions, etc.
Ces ressources sont des informations statiques stockées en dehors du code Java.
Ces ressources sont regroupées dans le fichier « apk » lors du processus de construction de
l’application[3].
[Link] ressources
Pourquoi les ressources?
Les ressources ont plusieurs objectifs, qui sont:
. - Séparation de la Logique et de l’Interface Utilisateur: Les ressources permettent de séparer le
code Java/Kotlin de l’interface utilisateur, facilitant ainsi la gestion et la maintenance.
- Faciliter la Localisation et l’Accessibilité : Les ressources permettent d’adapter facilement
l’application à différentes langues et configurations d’écran.
- Réutilisation: Les ressources peuvent être réutilisées dans toute l’application, réduisant ainsi la
duplication du code.
[Link] ressources
Caractéristiques de ressources?
Les ressources sont caractérisées par trois caractéristiques importantes, qui sont:
.- Modularité: Les ressources sont stockées dans des fichiers séparés, ce qui permet une gestion
modulaire et organisée.
- Adaptabilité: Les ressources peuvent être définies pour différentes configurations, telles que les
orientations d’écran, les tailles d’écran, et les langues.
- Simplicité d’Accès: Les ressources peuvent être facilement accédées et modifiées via le fichier
`[Link]` généré automatiquement par Android Studio.
[Link] ressources
Types de ressources?
On peut définir plusieurs types de ressource:
Ressources de Chaînes (Strings) : Texte utilisé dans l’application. Définies dans un fichier XML
sous `res/values/[Link]`.
Ressources de Couleurs (Colors) : Définition des couleurs utilisées dans l’application. Définies
dans un fichier XML sous `res/values/[Link]`.
Ressources de Dimensions (Dimensions): Valeurs numériques utilisées pour les tailles et les
espacements. Définies dans un fichier XML sous `res/values/[Link]`.
[Link] ressources
Types de ressources?
Ressources de Styles et Thèmes (Styles and Themes): Définitions des styles d’interface
utilisateur. Définies dans un fichier XML sous `res/values/[Link]`.
.
Ressources de Layout: Dispositions des éléments de l’interface utilisateur. Définies dans des
fichiers XML sous `res/layout/`.
Ressources de Dessins (Drawables): Images et graphiques utilisés dans l’application.
Définies sous `res/drawable/`.
Ressources Animées (Animations): Définitions d’animations. Définies sous `res/anim/`.
[Link] des ressources
.
[Link] des ressources
Les ressources sont organisées dans un répertoire (res) qui stocke les différentes
ressources associées à notre application.
Ces ressources sont organisées dans une hiérarchie particulière.
. Repertoire ressources
Les types de ressources
[Link] des ressources
Chaque ressource est définie avec son propre élément XML, vous pouvez nommer
le fichier que vous voulez et inclure différents types de ressources dans un seul
fichier.
. Cependant, pour plus de clarté, nous séparons les choses comme suit :
« [Link] » pour les tableaux des ressources.
« [Link] » pour les couleurs.
« [Link] » pour les dimensions.
« [Link] » pour les chaînes de caractères.
« [Link] » pour les styles.
[Link] des ressources
Utiliser les Ressources dans le Code Java/Kotlin
Accéder aux ressources de Chaînes (Strings) en Java:
String exampleString = getResources().getString([Link].example_string);
Accéder aux Ressources de Couleurs (Colors):
Int exampleColor = getResources().getColor([Link].example_color);
Accéder aux Ressources de Dimensions (Dimensions):
Float exampleDimension = getResources().getDimension([Link].example_dimension);
7. Comment Ajouter des Ressources dans Android Studio?
Ajouter des Ressources de Chaînes (Strings):
- Ouvrir le fichier `res/values/[Link]`.
- Ajouter une nouvelle chaîne par un code XML :
<string name=”example_string”>Ceci est un exemple de chaîne</string>
Ajouter des Ressources de Couleurs (Colors):
- Ouvrir le fichier `res/values/[Link]`.
- Ajouter une nouvelle couleur par un code XML :
<color name=”example_color”>#FFFFFF</color>
7. Comment Ajouter des Ressources dans Android Studio?
Ajouter des Ressources de Dimensions (Dimensions):
- Ouvrir le fichier `res/values/[Link]`.
- Ajouter une nouvelle dimension par un code XML:
<dimen name=”example_dimension”>16dp</dimen>
Ajouter des Ressources de Layout :
- Dans le dossier `res/layout/`, créer un nouveau fichier XML de disposition.
<LinearLayout xmlns:android=[Link]
Android:layout_width=”match_parent”
Android:layout_height=”match_parent”
Android:orientation=”vertical”>
<TextView
Android:layout_width=”wrap_content”
Android:layout_height=”wrap_content”
Android:text=”@string/example_string”/>
</LinearLayout>
7. Exemple d’application
Un exemple simple d’application Android utilisant des ressources. Cette application affichera un
texte et une image en utilisant les ressources définies dans des fichiers XML.
1/Structure du Projet
Nous allons créer une application
qui affiche un texte « Ressources
dans Android Studio » et une image
simple. La structure du projet
ressemblera à ceci :
7. Exemple d’application
2/Définir les ressources
a. [Link]
Ouvrez le fichier `res/values/[Link]` et ajoutez la chaîne suivante :
<resources>
<string name=”app_name”>MyApplication</string>
<string name=”hello_world”> Ressources dans Android Studio </string>
</resources>
7. Exemple d’application
2/Définir les ressources
b. [Link]
Ouvrez le fichier `res/values/[Link]` et ajoutez la couleur suivante :
<resources>
<color name=”colorPrimary”>#6200EE</color>
<color name=”colorPrimaryDark”>#3700B3</color>
<color name=”colorAccent”>#03DAC5</color>
</resources>
7. Exemple d’application
2/Définir les ressources
b. [Link]
Ouvrez le fichier `res/values/[Link]` et ajoutez les dimensions suivantes :
<resources>
<dimen name=”activity_horizontal_margin”>16dp</dimen>
<dimen name=”activity_vertical_margin”>16dp</dimen>
</resources>
d. Image
Ajoutez une image nommée `example_image.png` dans le dossier `res/drawable/`.
7. Exemple d’application
3/Créer le Layout
activity_main.xml
Ouvrez le fichier `res/layout/activity_main.xml` et définissez la mise en page suivante:
<LinearLayout
xmlns:android=[Link]
Android:layout_width=”match_parent”
Android:layout_height=”match_parent”
Android:orientation=”vertical”
Android:padding=”@dimen/activity_horizontal_margin”>
7. Exemple d’application
3/Créer le Layout
<TextView
Android:layout_width=”wrap_content”
Android:layout_height=”wrap_content”
Android:text=”@string/hello_world”
Android:textSize=”18sp”
Android:textColor=”@color/colorPrimary”/>
<ImageView
Android:layout_width=”wrap_content”
Android:layout_height=”wrap_content”
Android:src=”@drawable/example_image”
Android:contentDescription=”@string/hello_world”/>
</LinearLayout>
4/Créer l’Activité
[Link]
Ouvrez ou créez le fichier `[Link]` dans le dossier
`java/com/example/myapplication/` et ajoutez le code suivant :
Package [Link];
Import [Link];
Import [Link];
Public class MainActivity extends AppCompatActivity {
@Override
Protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
setContentView([Link].activity_main);
}
}
5/Exécuter l’application
1. Connectez votre appareil Android ou démarrez un émulateur.
2. Cliquez sur le bouton de lecture (Run) dans Android Studio pour exécuter l’application.
3. L’application devrait afficher le texte “Ressources dans Android Studio” et l’image que vous
avez ajoutée.
