Département GI

Module : UML & développement

mobile sous Android
Elément : Développement mobile
sous Android
Travaux Pratiques 3 : Android
Service

1
Prof. Dr. Yassine Rhazali
1.1 activity_main.xml
2 Les types de services sur Android
Un service est un composant qui s'exécute en arrière-plan pour effectuer des opérations de longue
durée sans avoir à interagir avec l'utilisateur et il fonctionne même si l'application est détruite. Un
service peut essentiellement prendre deux états.

État Description
Un service est started (démarre) lorsqu'un composant d'application, tel qu'une
Started Activity, démarre en appelant startService(). Une fois démarré, un service peut
s'exécuter en arrière-plan indéfiniment, même si le composant qui l'a démarré,
(Démarré) est détruit.

Ce service est également connu sous le nom un service illimité (UnBounded

Service).
Un service est bound (relié) lorsqu'un composant d'application se lie à celui- ci
Bound appelant bindService(). Un service relié offre une interface client-serveur qui
permet aux composants d'interagir avec le service, d'envoyer des requêtes,
(Relié) d'obtenir des résultats et même de les faire dans tous des processus avec
communication interprocessus (IPC).

Un service a des méthodes de rappel de cycle de vie (life cycle callback methods) que vous pouvez
mettre en oeuvre (implement) pour surveiller les changements dans l'état du service et vous pouvez
effectuer un travail au stade approprié. Le diagramme suivant à gauche montre le cycle de vie
lorsque le service est créé avec startService() et le diagramme de droite montre le cycle de vie
lorsque le service est créé avec bindService().

2
Prof. Dr. Yassine Rhazali
Pour créer un service, vous créez une classe Java qui étend la classe de Base de service ou l'une de
ses sous-classes existantes. La classe de base du service définit diverrses méthodes de rappel et les
plus importantes sont données ci-dessous. Vous n'avez pas besoin de mettre en œuvre
(implements) toutes les méthodes de rappel. Cependant, il est important que vous compreniez
chacun et mettez en œuvre ceux qui garantissent que votre application se comporte de la façon dont
les utilisateurs attendent.

En outre, il existe un autre service appelé IntentService. IntentService est utilisé pour effectuer une
tâche unique, c'est-à-dire lorsque la tâche complète le service se détruit.

3
Prof. Dr. Yassine Rhazali
 4
Prof. Dr. Yassine Rhazali
Comparaison des services:

Unbound Service Bound Service Intent

(Service non relié) (Relié) Service
Bounded Service est utilisé
Unbounded Service est Intent Service est utilisé pour
pour effectuer une tâche
utilisé pour effectuer effectuer une tâche unique, c'est-
d'arrière- plan
une longue tâche à-dire lorsque la tâche complète
(background) en liaison avec
répétitive. le service se détruit.
un autre composant.

Unbound Intent Service démarre en

Bounded Service démarre en
Service démarre en appelant startService().
appelant bindService().
appelant startService().

Unbound Service est Bounded Service est IntentService appelle

arrêté ou détruit déconnecté ou détruit en implicitement la méthode
explicitement en appelant unbindService(). stopself() pour détruire
appelant stopService().

Unbound Service est Bound Service est dépendant Intent Service est indépendant
indépendant du du composant dans lequel il du composant dans lequel il est
composant dans lequel est démarré. démarré.
il est démarré

Les méthodes de rappel et la description:

Callback Description
Le système appelle cette méthode lorsqu'un autre composant, tel qu'une
activité, demande que le service soit démarré, en appelant startService (). Si
onStartCommand() vous implémentez cette méthode, il est de votre responsabilité d'arrêter le
service une fois son travail terminé, en appelant les méthodes stopSelf () ou
stopService ().
Le système appelle cette méthode lorsqu'un autre composant souhaite se
lier au service en appelant bindService (). Si vous implémentez cette
méthode, vous devez fournir une interface que les clients utilisent pour
onBind()
communiquer avec le service, en renvoyant un objet IBinder. Vous devez
toujours implémenter cette méthode, mais si vous ne souhaitez pas
autoriser la liaison, vous devez retourner null.
Le système appelle cette méthode lorsque tous les clients se sont
onUnbind()
déconnectés d'une interface particulière publiée par le service.
Le système appelle cette méthode lorsque de nouveaux clients se sont
onRebind() connectés au service, après avoir été préalablement averti que tous
s'étaient déconnectés dans son onUnbind (intention).
Le système appelle cette méthode lorsque le service est créé pour la
onCreate() première fois à l'aide de onStartCommand () ou onBind (). Cet appel est
nécessaire pour effectuer une configuration unique.
Le système appelle cette méthode lorsque le service n'est plus utilisé et est
onDestroy() en cours de destruction. Votre service doit l'implémenter pour nettoyer
toutes les ressources telles que les threads, les écouteurs enregistrés, les

5
Prof. Dr. Yassine Rhazali
 récepteurs, etc.

3 Service illimité (Un bounded Service)

Unbound Service (ou Started Service): Dans ce cas, un composant d'application démarre le service
en appelant startService (), et il continuera à s'exécuter en arrière-plan, même si le composant
d'origine qui l'a déclenché est détruit. Par exemple, au démarrage, un service continuerait de jouer
de la musique en arrière-plan indéfiniment.

6
Prof. Dr. Yassine Rhazali
La méthode onStartCommand() renvoie le type integer, et il est une des valeurs ci- dessous:

7
Prof. Dr. Yassine Rhazali
 • START_STICKY
• START_NOT_STICKY
• TART_REDELIVER_INTENT

START_STICKY & START_NOT_STICKY

• Les deux valeurs ne sont pertinentes que lorsque le téléphone manque de mémoire
et tue le service avant qu'il ne soit terminé.
• START_STICKY indique au système d'exploitation de recréer le service après avoir
suffisamment de mémoire et d'appeler onStartCommand() encore avec une Intent
nulle.
• START_NOT_STICKY indique à l'OS de ne plus déranger de recréer le service.

Il y a encore le troisième code START_REDELIVER_INTENT qui indique au système d'exploitation de

récréer des services et redélivrer un pareil Intent pour onStartCommand().

Exemple de la lecture de la musique (Exécuter en arrière- plan)

Créez un nouveau projet "Empty Activity" baptisé PlaySongService

• Name: PlaySongService
8
Prof. Dr. Yassine Rhazali
 • Package name: org.o7planning.playsongservice

Le projet est créé.

Préparez le fichier mp3:

Cliquez sur le bouton droit sur le dossier res et sélectionnez:

• New > Folder > Raw Resources Folder

9
Prof. Dr. Yassine Rhazali
Copier et Coller un fichier de la musique mp3 dans le dossier 'raw' que vous venez de créer.

10
Prof. Dr. Yassine Rhazali
Conception de l'interface de l'application:

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>

1
<androidx.constraintlayout.widget.ConstraintLayout
2
xmlns:android="http://schemas.android.com/apk/res/android"
3
xmlns:app="http://schemas.android.com/apk/res-auto"
4
xmlns:tools="http://schemas.android.com/tools"
5
android:layout_width="match_parent"

11
Prof. Dr. Yassine Rhazali
6 android:layout_height="match_parent"

7 tools:context=".MainActivity">

8
<Button
9
android:id="@+id/button_play"
10
android:layout_width="wrap_content"
11
android:layout_height="wrap_content"
12
android:layout_marginTop="28dp"
13
android:text="Play"
14 app:layout_constraintEnd_toEndOf="parent"

15 app:layout_constraintStart_toStartOf="parent"

16 app:layout_constraintTop_toTopOf="parent" />

17

18 <Button

android:id="@+id/button_stop"
19
android:layout_width="wrap_content"
20
android:layout_height="wrap_content"
21
android:layout_marginTop="37dp"
22
android:text="Stop"
23
app:layout_constraintEnd_toEndOf="parent"
24 app:layout_constraintStart_toStartOf="parent"

25 app:layout_constraintTop_toBottomOf="@+id/button_play" />

26</androidx.constraintlayout.widget.ConstraintLayout>

3.1 Créer une classe de service

Cliquez sur le bouton droit sur un paquet Java, sélectionnez:

• New > Service > Service

12
Prof. Dr. Yassine Rhazali
Saisissez le nom de la classe:

• PlaySongService

13
Prof. Dr. Yassine Rhazali
Vous pouvez voir que PlaySongService a été déclaré avec AndroidManifest.xml:

** AndroidManifest.xml **

1 <?xml version="1.0" encoding="utf-8"?>

14
Prof. Dr. Yassine Rhazali
2 <manifest xmlns:android="http://schemas.android.com/apk/res/android"

3 package="org.o7planning.playsongservice">

4
<application ...>
5

6
<service
7
android:name=".PlaySongService"
8
android:enabled="true"
9
android:exported="true"></service>
10

11
....
12

13 </application>

14

15</manifest>

16

PlaySongService.java

1 package org.o7planning.playsongservice;
2
import android.app.Service;
3 import android.content.Intent;
4 import android.os.IBinder;
5 import android.media.MediaPlayer;
6
7 public class PlaySongService extends Service {
8
private MediaPlayer mediaPlayer;
9
10 public PlaySongService() {
11 }
12
13 // Return the communication channel to the service.
14 @Override
15 public IBinder onBind(Intent intent){
// This service is unbounded
16 // So this method is never called.
17 return null;

15
Prof. Dr. Yassine Rhazali
18 }
19
20
@Override
21
public void onCreate(){
22 super.onCreate();
23 // Create MediaPlayer object, to play your song.
24 mediaPlayer = MediaPlayer.create(getApplicationContext(),
25 R.raw.mysong);
}
26
27 @Override
28 public int onStartCommand(Intent intent, int flags, int startId){
29 // Play song.
30 mediaPlayer.start();
31
32 return START_STICKY;
}
33
34 // Destroy
35 @Override
36 public void onDestroy() {
37 // Release the resources
mediaPlayer.release();
38 super.onDestroy();
39 }
40}
41

MainActivity.java

1 package org.o7planning.playsongservice;
2
3 import androidx.appcompat.app.AppCompatActivity;
4
import android.os.Bundle;
5 import android.content.Intent;
6 import android.view.View;
7 import android.widget.Button;
8
9 public class MainActivity extends AppCompatActivity {
10
private Button buttonPlay;
11 private Button buttonStop;
12
13 @Override
14 protected void onCreate(Bundle savedInstanceState) {
15 super.onCreate(savedInstanceState);
16 setContentView(R.layout.activity_main);
17
this.buttonPlay = (Button) this.findViewById(R.id.button_play);
18 this.buttonStop = (Button) this.findViewById(R.id.button_stop);
19
20 this.buttonPlay.setOnClickListener(new View.OnClickListener() {
21 @Override

16
Prof. Dr. Yassine Rhazali
22 public void onClick(View v) {
playSong();
23 }
24 });
25
26 this.buttonStop.setOnClickListener(new View.OnClickListener() {
27 @Override
28 public void onClick(View v) {
stopSong();
29 }
30 });
31 }
32
33 // This method is called when users click on the Play button.
34 public void playSong() {
// Create Intent object for PlaySongService.
35 Intent myIntent = new Intent(MainActivity.this,
36PlaySongService.class);
37
38 // Call startService with Intent parameter.
39 this.startService(myIntent);
}
40
41 // This method is called when users click on the Stop button.
42 public void stopSong( ) {
43
44 // Create Intent object
45 Intent myIntent = new Intent(MainActivity.this,
46PlaySongService.class);
this.stopService(myIntent);
47 }
48
49}

Voici l’exécution de l’application

17
Prof. Dr. Yassine Rhazali
 18
Prof. Dr. Yassine Rhazali