Module 12 - Développement D - Applications Mobiles

ROYAUME DU MAROC
Office de la Formation Professionnelle et de la Promotion du Travail
Développement d'applications mobiles
DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

SECTEUR NTIC
OFPPT
Technicien en Techniques de Développement Informatique
Guide des travaux pratiques
Module 12 :
Développement d'applications mobiles
Android Studio
et
Java
Hamid Mask
Formateur en TDI
2 / 98
Créez des applications pour Android
I - Installation et configuration des outils

1 – Le matériel :
Il faut vérifier que votre machine de développement possède :
 RAM 4 Go (fonctionnement lourd). 8 Go recommandé.

 Disque 6 Go.
2 – Système d’exploitation :
 Pour Windows : Windows Vista ou plus récent.

 Pour Mac OS : Mac OS 10.8.5 ou plus récent.
3 – Le Java Development Kit (JDK)

Pour développer en Java, nous devons installer le JDK (pour «Java Development Kit»).
Il existe deux plateformes en Java :
 Le JRE (Java Runtime Environment), qui contient la JVM (Java Virtual Machine. En
gros, c'est l'ensemble des outils qui vous permettra d’exécuter des applications Java.
 Le JDK (Java Development Kit), qui contient le JRE (afin d’exécuter les applications
Java), mais aussi un ensemble d'outils pour compiler et déboguer votre code.
4 – Téléchargement et installation du JDK :
Voici le lien de téléchargement :

http://www.oracle.com/technetwork/java/javase/downloads/index.html
Cliquez sur Download en dessous de JDK :
3 / 98
Cliquez sur (Accept License Agreement) avant de continuer.
Choisissez ensuite la version adaptée à votre configuration. Une fois le téléchargement

terminé, vous pouvez l’installer.
5 – Téléchargement et installation d’Android Studio et le SDK Android :
On va maintenant télécharger un pack (fichier) qui contient Android Studio et un outil

pour gérer l'installation du SDK Android sur votre système.
Android Studio est un environnement de développement (EDI) spécialisé dans le

développement d'applications Android. C’est l'IDE privilégié par Google pour le
développement Android.
Voici le lien de téléchargement :

https://developer.android.com/sdk/installing/studio.html
Cliquez sur Download Android Studio pour démarrer le téléchargement :
4 / 98
C'est quoi un SDK ?
Les applications Android sont développées en Java, mais un appareil sous Android ne
comprend pas le Java tel quel, il comprend une variante du Java adaptée pour Android.
Un SDK, un kit de développement, est un ensemble d'outils permettant de développer pour un

type d’appareil particulier. Par exemple pour développer pour une console de jeu vidéo, on
utilise un SDK spécifique pour développer des applications pour cette console.
Une fois le téléchargement terminé, lancez l'installation. Pendant l'installation, vous devrez
répondre à certaines questions :
Sélectionnez les options en fonction de votre matériel puis cliquez sur "Next".
(Conservez les options Android SDK et Android Virtual Device).
5 / 98
Indiquez où vous souhaitez que Android Studio et le SDK soient installés, puis cliquez sur
Next:
6 / 98
Une fois l'installation terminée, lancez Android Studio.
5 – Création de votre premier projet :
Dans la fenêtre Android Studio cliquez sur Start a new Android Studio Project pour
ouvrir l'assistant de création de projet.
Cliquez sur Start a new Android Studio Project
Une nouvelle fenêtre s'ouvrira. Elle contient trois champs :
C’est la première étape de création d'un projet
7 / 98
 Application Name : c’est le nom qui apparaîtra sur l'appareil et sur Google Play.
 Company Domain : c’est le nom de domaine de votre entreprise (Exemple :

tdi2.com).
 Project Location : indiquez ici l'emplacement où les fichiers de votre projet seront
créés.
Cliquez sur Next pour passer à l'écran suivant.
Cet écran vous permet de sélectionner le matériel de destination de votre application,

ainsi que la version d'Android minimum que doit utiliser ce matériel. Sélectionnez la version la
plus récente.
Une fois votre sélection faites, cliquez sur Next.
8 / 98
Création de la première activité.
Sélectionnez Empty Activity et cliquez sur Next.
Ce sont des informations sur la première activité de notre application.
Cliquez juste sur Finish .
Vous pouvez constater qu’un projet avec une activité de type Empty Activity contient
un label au milieu qui affiche le message "Hello World !".
Pour exécuter ce programme il faudra relier votre mobile Android via un câble USB à
votre PC, ou bien installer un émulateur (un téléphone sur l’écran de votre PC).
C’est le sujet des deux paragraphes suivants.
II – Configuration du téléphone (Appareil réel).

Votre téléphone doit être configuré de façon à ce qu’il puisse exécuter des applications que vous avez
développé. Pour cela, allez dans les paramètres du téléphone :
 Choisissez l'option :
Options de développement
 Activer l'option Débogage USB
Si Options de développement n’apparait pas allez dans :

Paramètres  A propos de l’appareil et appuyer sur Numéro de version sept fois.
Retournez ensuite à l’écran Paramètres, vous verrez apparaitre Options de développement.
III – Création d’une machine virtuelle.

Une machine virtuelle est un logiciel qui va simuler une machine physique avec ses
caractéristiques propres. Par exemple, nous avons l’habitude d’utiliser parfois des machines
9 / 98
virtuelles Linux sur un ordinateur Windows pour faire du développement sous ces
environnements.
Nous allons donc apprendre comment créer une machine virtuelle qui simulera une
machine qui exécute Android afin que nous puissions exécuter nos applications directement
sur notre ordinateur.
Nous allons faire cela dans le paragraphe suivant.
IV – Notions de base.
On va tout d'abord voir ce qu'on appelle des activités et comment les manipuler.
Sachant que la majorité de vos applications contiendront plusieurs activités.
Nous verrons aussi ce que sont les vues et nous créerons enfin notre premier projet.
1 - Qu'est-ce qu'une activité ?
Si vous observez l’architecture de la majorité des applications Android, vous

remarquerez qu’elles sont structurées à peu près de la même façon. Une application est un
assemblage de fenêtres entre lesquelles il est possible de naviguer.
Ces différentes fenêtres sont appelées des activités. Une activité est une interface
graphique et elle remplit tout l'écran. Par conséquent, une application ne peut afficher qu'une
seule activité à la fois. La figure suivante illustre ce phénomène.
En cliquant sur un élément de la liste à gauche, on ouvre une nouvelle activité.
De plus, une activité contient des informations sur l'état actuel de l'application : ces
informations s'appellent le context. Ce context constitue un lien avec le système Android
ainsi que les autres activités de l'application, comme le montre la figure suivante.
10 / 98
Context = l’ensemble des ressources utilisées.
Une activité est constituée du contexte de l'application et d'une seule et unique interface
graphique.
2 - États d'une activité
Si un utilisateur reçoit un appel, il devient plus important qu'il puisse y répondre que de
faire autre chose. La règle est la suivante :
À tout moment votre application peut laisser place à une autre application, qui a
une priorité plus élevée.
Une activité existera dans plusieurs états au cours de sa vie, par exemple un état actif
pendant lequel l'utilisateur l'exploite, et un état de pause quand l'utilisateur reçoit un appel.
Plus clairement, quand une application se lance, elle se met tout en haut de ce qu'on
appelle la pile d'activités.
Une pile est une structure de données de type « LIFO » (Last In First Out = Dernier
Entré Premier Sortie), c'est-à-dire qu'il n'est possible de n'avoir accès qu'à un seul élément de
la pile, le tout premier élément, aussi appelé sommet. Quand on ajoute un élément à cette
pile, le nouvel élément prendra la première place et deviendra le nouveau sommet. Quand on
veut récupérer un élément, ce sera le sommet qui sera récupéré, sorti de la liste et l'objet en
deuxième place deviendra le nouveau sommet, comme illustré à la figure suivante :
11 / 98
Fonctionnement de la pile d'activités
L'activité que voit l'utilisateur est celle qui se trouve au-dessus de la pile. Ainsi, lorsqu'un
appel (ou un message) arrive, il se place au sommet de la pile et c'est lui qui s'affiche à la
place de votre application, qui n'est plus qu'à la deuxième place. Votre activité ne reviendra
qu'à partir du moment où toutes les activités qui se trouvent au-dessus d'elle seront arrêtées et
sorties de la pile. On retrouve ainsi le principe expliqué précédemment, on ne peut avoir
qu'une application visible en même temps sur le terminal, et ce qui est visible est l'interface
graphique de l'activité qui se trouve au sommet de la pile.
Une activité peut se trouver dans les trois états suivants :

 Actif (Active) : L'activité est visible en totalité. C'est ce que l'utilisateur consulte en ce
moment même.
 Suspendu (Paused) : L'activité est partiellement visible à l'écran. C'est le cas quand
vous recevez un SMS. L'utilisateur devra se débarrasser de l'application partiellement
au-dessus pour qu’il puisse à nouveau interagir avec notre activité.
 Arrêté (Stopped) : L'activité est tout simplement invisible pour l'utilisateur, car une
autre activité prend toute la place sur l'écran. Le système peut redémarrer l’application
ou la détruire pour libérer de la mémoire.
3 - Cycle de vie d'une activité
Une activité n'a pas de contrôle direct sur son propre état (et par conséquent vous non
plus en tant que programmeur), il s'agit plutôt d'un cycle rythmé par les interactions avec le
système et d'autres applications. Voici un schéma qui présente ce que l'on appelle le cycle de
vie d'une activité, c'est-à-dire qu'il indique les étapes que va traverser notre activité pendant
sa vie, de sa naissance à sa mort. Vous verrez que chaque étape du cycle est représentée par
une méthode. Nous verrons comment utiliser ces méthodes en temps voulu.
12 / 98
Cycle de vie d'une activité
Qui peut être représenté aussi de la manière suivante :
 Created : l’activité a été créée et prête à être affiché.
 Started : l’activité est visible, mais l’utilisateur ne peut l’utiliser. Cet état est immédiatement suivi par
l’état Resumed.
 Resumed : l’activité est en exécution en avant plan et peut être utilisé par l’utilisateur. (démarrer ou
redémarrer).
13 / 98
 Paused : l’activité est interrompue par un appel téléphonique ou un message. Elle se trouve dans un
état stoppé. L’activité est toujours visible, mais derrière une boite de dialogue et l’utilisateur ne peut
l’utiliser.
 Stopped : l’activité est déplacée en arrière-plan et devient donc invisible, mais l’instance existe
toujours en mémoire. Une activité peut être relancée à partir de cet état sans la recréer.
 Destroyed : l’activité est détruite par le système et n’existe plus.
Les activités héritent de la classe Activity.

On les trouve dans le package android.app.Activity.
Un package = un espace de nom.
4 - Création d’une machine virtuelle (ou émulateur).
 Aller au menu :
Tools  Android  AVD Manager
 Ou bien Cliquez sur l’icône :
Cliquez sur le bouton Create Virtual Device en bas de l'écran :
14 / 98
Écran de sélection du matériel à émuler
On a choisi de créer un équipement qui correspondra à un Nexus 5, on le sélectionne donc dans le menu
central et on clique sur Next.
Nous pouvons sélectionner ici une version d'Android à installer sur notre AVD
15 / 98
Les derniers paramètres pour notre AVD
Enfin, nous allons pouvoir sélectionner les derniers paramètres pour notre AVD. Nous gardons
toutes les valeurs proposées.
 Cliquer sur Finish directement.
Notre machine virtuelle a été créée avec succès.
16 / 98
V – Exemples d’applications simples.
1 – Hello World !
 Choisisser New Project :

Application name : PremiereApplication
Campany domain : tdi2.ma
Le Manifeste : AndroidManifest.xml (ensemble d’informations sur l’application).
MainActivity (Class Java)
Le Layout :
17 / 98
Après exécution sur notre émulateur :
L’application est bien installée dans l’émulateur :
18 / 98
Notre application devient une application parmi les nombreuses applications sur notre téléphone.
19 / 98
2 – Copier un Texte : TextView – Button - EditView

Application name : Application-01
Le Layout :
MainActivity contient les Views (Widgets) suivants :
 Un TextBox : editText1
 Un Bouton : buttonCopier
 Un label : textView1
20 / 98
21 / 98
3 – Compter les clics : TextView – 2 Buttons

Application name : Application-02
Le Layout : nous avons utilisé un RelativeLayout pour placer les Views les unes après les
autres.
 Un label : textView
 Deux Boutons : buttonClick et buttonReset
MainActivity.java
package introduction.application_02;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
Button btnClick;
Button btnReset;
TextView txt;
22 / 98
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnClick = (Button) findViewById(R.id.buttonClick);

btnReset = (Button) findViewById(R.id.buttonReset);
txt = (TextView) findViewById(R.id.textView);
btnClick.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
int Cpt = Integer.parseInt(txt.getText().toString());

Cpt++;
txt.setText(String.valueOf(Cpt));
}
});
btnReset.setOnClickListener(new View.OnClickListener() {
@Override
txt.setText(String.valueOf(0));
}
});
}
}
Exécution de l’application :
23 / 98
24 / 98
4 – Nombres aléatoires : Générer des nombres aléatoires à l’aide de la
fonction Random().
Etape 1 : Générer des nombres aléatoires (Entre 0 et 100).
 New Project :
Application name : ApplicationAleatoire
Le Layout : nous avons utilisé un RelativeLayout pour placer les Views les unes
après les autres.
 Un label : textView1
 Un Bouton : buttonOK
MainActivity.java
package ma.tdi2.applicationaleatoire;
TextView txtResultat;
Button btnOK;
25 / 98
@Override
txtResultat = (TextView) findViewById(R.id.textView1);

btnOK = (Button) findViewById(R.id.buttonOK);
btnOK.setOnClickListener(new View.OnClickListener() {
@Override
int valeur = (int) (Math.random()*100);
txtResultat.setText(Integer.toString(valeur));
}
});
}
}
Exécution de l’application : l’application génère bien des nombres aléatoires.
26 / 98
27 / 98
Faire des Tests
28 / 98
Etape 2 : deviner le nombre aléatoire généré.
 Un label : textView1
 Un bouton : buttonOK
 Un textBox : EditView1
29 / 98
MainActivity.java
import android.widget.EditText;
Button btnOK;
EditText edTSaisie;
@Override

edTSaisie = (EditText) findViewById(R.id.editTextSaisie);
@Override
int valeurSaisie = Integer.parseInt(edTSaisie.getText().toString());
if ( valeur == valeurSaisie) {
// Cas : L'utilisateur gagne
txtResultat.setText("Bravo, vous avez gagné !");
}
else {
// Cas : L'utilisateur a perdu
txtResultat.setText("Perdu !");
}
}
});
}
}
30 / 98
Etape 3 : deviner le nombre aléatoire généré qui sera ensuite affiché.
Remplaçons le message "Perdu !" par "Perdu ! Il fallait entrer : " + valeur
Voici le résultat :
31 / 98
Les tests if-else imbriqués
Etape 4 : deviner et comparer la valeurSaisie à la valeur aléatoire.
Ici, nous voulons, dans le cas valeur != valeurSaisie, tester si la valeurSaisie est plus
petite ou plus grande que valeur.
Le code devient :

}
else {
if ( valeurSaisie > valeur){
txtResultat.setText("Perdu Valeur trop grande ! Il fallait entrer : " + valeur);
}
else {
txtResultat.setText("Perdu Valeur trop petite ! Il fallait entrer : " + valeur);
}
32 / 98
Etape 5 : deviner un nombre aléatoire fixe et le comparer la
valeurSaisie.
Le jeu précédent ne nous donne pas l’occasion de gagner. Il faudra que le nombre
aléatoire reste fixe pour pouvoir le deviner. Il faudra aussi ne pas afficher sa valeur.
Le code devient :
Button btnOK;
EditText edTSaisie;
int valeur; // Variable de classe (Globale)
@Override

edTSaisie = (EditText) findViewById(R.id.editTextSaisie);
valeur = (int) (Math.random()*100); // Valeur aléatoire fixe
33 / 98
@Override
}
else {
if ( valeurSaisie > valeur){
txtResultat.setText("Perdu Valeur trop grande !");
}
else {
txtResultat.setText("Perdu Valeur trop petite !");
}
}
});
}
}
34 / 98
35 / 98
5 – Deux activités : une activité qui appelle une autre en cliquant sur une
image.
Etape 1 : Ajouter un ImageView pour afficher une image.
 New Project :
Application name : AppDeuxActivites
Le Layout : nous allons utiliser un RelativeLayout pour placer les Views les
unes après les autres.
 Ajouter les Views suivants :

 Deux TextView(s) : textView1 et textView2
 Un ImageView : Jeu
Avant d’ajouter l’ImageView, il faudra mettre l’image terre.jpg dans le dossier drawable.
L’imageView sera utilisé pour passer de cette activité à la deuxième activité, par simple clic
dessus.
Une fois l’ImageView glissé au milieu de l’activité, une fenêtre s’ouvrira pour la sélection de
l’image terre.jpg.
 Ouvrer le fichier string.xml (app  res  values) et ajouter les 2 strings suivants :
<string name="Welcome">Bienvenue sur mon application</string>

<string name="Hello">Hello World!</string>
36 / 98
 Modifier le Texte des deux textViews dans le fichier activity_main.xml :
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/Hello" 
......
<TextView
android:layout_below="@+id/Jeu"
android:layout_centerHorizontal="true"
android:layout_marginTop="24dp"
android:text="@string/Welcome" 
......
Etape 2 : Créer une deuxième activité CookieActivity.
 File  New  New Activity  Empty Activity :
Activity name : CookieActivity

Layout name : activity_cookie
Package name : ma.tdi2.deuxactivites
 Ajouter un RelativeLayout à cette activité.

 Ajouter à l’intérieur de ce Layout les Views suivants :
37 / 98
Avant d’ajouter l’ImageView, il faudra mettre les images cookie.png et fondecran14.jpg dans le
dossier drawable.
L’imageView, cette fois-ci, sera utilisé pour compter les clics sur l’image cookie.png.
 Ouvrer le fichier string.xml (app  res  values) et ajouter les 2 strings suivants :
<string name="Point_Nb">Points : </string>
 Ouvrer le fichier color.xml (app  res  values) et ajouter une couleur :
<color name="White">#fff</color>
 Modifier le texte du textView et sa couleur dans le fichier activity_cookie.xml :
<TextView
android:id="@+id/points"
android:text="@string/Point_Nb" 
android:textColor="@color/White" 

......
CookieActivity :
Pour faire communiquer les deux activés (l’activité principale et celle que nous
venons de créer) il faut passer par un Intent.
Un Intent représente l’intention de faire quelque chose, et permet à l’activité principale de
lancer la deuxième activité.
38 / 98
Pour appeler l’activité CookieActivity en cliquant sur l’image de l’activité MainActivity, on doit
ajouter à cette dernière le code suivant :
MainActivity.java
package ma.tdi2.deuxactivites;
import android.content.Intent;
import android.widget.ImageView;
private ImageView jeu;
@Override
jeu = (ImageView) findViewById(R.id.Jeu);
jeu.setOnClickListener(new View.OnClickListener() {
@Override
Intent autreActivity = new
Intent(getApplicationContext(),CookieActivity.class);
startActivity(autreActivity);
finish();
}
});
}
}
Une fois la deuxième activité (CookieActivity) affichée, un clic sur l’image incrémente la valeur
du nombre affiché dans le textView.
Pour réaliser cela, ajouter le code suivant :
CookieActivity.java
package ma.tdi2.deuxactivites;
import android.widget.ImageView;
39 / 98
public class CookieActivity extends AppCompatActivity {
private TextView points;
private ImageView cookie;
private int clicks = 0;
@Override
setContentView(R.layout.activity_cookie);
points = (TextView) findViewById(R.id.points);

cookie = (ImageView) findViewById(R.id.cookie);
cookie.setOnClickListener(new View.OnClickListener() {
@Override
clicks++;
points.setText("Points : " + clicks);
}
});
}
}
40 / 98
MainActivity.java
package ma.tdi2.apptwoactivities;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.widget.Toolbar;
import android.view.Menu;
import android.view.MenuItem;
private EditText champ_saisie;

public final static String MESSAGE_SUPP = ""; //"ma.tdi2.apptwoactivities.MESSAGE";
41 / 98
@Override
Toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);

fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View) {
Snackbar.make(view, "Replace with your own action",
Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action1) {
Intent intent = new Intent(this,Client.class);
startActivity(intent);
}
Intent intent = new Intent(this,Client.class);
}
finish();
}
return super.onOptionsItemSelected(item);
}
public void envoiMessage (View){

champ_saisie = (EditText) findViewById(R.id.champ_saisie);
42 / 98
Intent = new Intent(this, AffichMessage. class);
String message = champ_saisie.getText().toString();
intent.putExtra(MESSAGE_SUPP, message);
//champ_saisie.setText("Bonjour");
}
}
Menu_main.xml
43 / 98
AffichMessage.java
package ma.tdi2.apptwoactivities;
import android.widget.TableLayout;
public class AffichMessage extends AppCompatActivity {
private TextView textView1;
@Override
setContentView(R.layout.activity_affich_message);
Toolbar = (Toolbar) findViewById(R.id.toolbar);

@Override
public void onClick(View) {
}
});
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
Intent = getIntent();
String message = intent.getStringExtra(MainActivity.MESSAGE_SUPP);
textView1 = (TextView) findViewById(R.id.textView1);
textView1.setText(message);
44 / 98
TP : Gestion Clients
Activity_main.xml (MainActivity)
<?xml version="1.0" encoding="utf-8"?>

<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TableLayout
android:layout_width="368dp"
android:layout_height="495dp"
android:background="@drawable/background7"
android:stretchColumns="1"
tools:layout_editor_absoluteX="8dp"
tools:layout_editor_absoluteY="8dp">
<TableRow>
<TextView
android:text="Nom :"
android:textSize="24sp"
android:textStyle="bold" />
<EditText
android:id="@+id/nom"
android:textSize="24sp" />
</TableRow>
<TableRow>
<TextView
android:text="Prenom :"
<EditText
android:id="@+id/prenom"
</TableRow>
<Button
android:id="@+id/save"
android:layout_width="fill_parent"
45 / 98
android:text="Save"
</TableLayout>
</android.support.constraint.ConstraintLayout>
46 / 98
Ajouter un TableRow dans lequel on mettra un TextView et un RadioGroup :
<TableRow>
<TextView
android:text="Sexe :"
<RadioGroup android:id="@+id/sexes">
<RadioButton
android:id="@+id/male"
android:text="Male"
<RadioButton
android:id="@+id/femelle"
android:text="Femelle"
</RadioGroup>
</TableRow>
47 / 98
Créer une classe Client :
Client.java
package ma.tdi2.gestionclients;
/**
* Created by MASK on 27/02/2018.
*/
public final class Client {

private String Nom="";
private String Prenom="";
private String Sexe="";
public String getNom() {

return Nom;
}
public void setNom(String nom) {

Nom = nom;
}
public String getPrenom() {

return Prenom;
}
public void setPrenom(String prenom) {

Prenom = prenom;
}
public String getSexe() {

return Sexe;
48 / 98
}
public void setSexe(String sexe) {

Sexe = sexe;
}
Créer un nouveau client et affecter des valeurs à ses attributs :
MainActivity.java
import android.widget.RadioButton;
import android.widget.RadioGroup;
Client cl = new Client();
@Override
Button save=(Button) findViewById(R.id.save);
save.setOnClickListener(new View.OnClickListener() {
@Override
EditText nom=(EditText) findViewById(R.id.nom);
EditText prenom=(EditText) findViewById(R.id.prenom);
cl.setNom(nom.getText().toString());
cl.setPrenom(prenom.getText().toString());
RadioGroup sexes=(RadioGroup) findViewById(R.id.sexes);
switch (sexes.getCheckedRadioButtonId()) {
case R.id.male:
cl.setSexe("Male");
break;
case R.id.femelle:
cl.setSexe("Femelle");
break;
}
}
});
}
}
Rien ne se pas lors de l’exécution, car l’instance n’est pas utilisée !
Voici Activity_main.xml avant l’ajout d’une ListView :
49 / 98
<android.support.constraint.ConstraintLayout
<TableLayout
android:background="@drawable/background7"
tools:layout_editor_absoluteX="8dp"
tools:layout_editor_absoluteY="8dp">
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<RadioGroup android:id="@+id/sexes">
<RadioButton
android:id="@+id/male"
android:text="Male"
<RadioButton
android:id="@+id/femelle"
android:text="Femelle"
</RadioGroup>
</TableRow>
<Button
android:text="Save"
</TableLayout>
</android.support.constraint.ConstraintLayout>
50 / 98
1 - Manipuler une liste de clients.
List<Client> listClient = new ArrayList<Client>();
Ajouter l’instance Client à la liste listClient :
import java.util.ArrayList;
import java.util.List;
List<Client> listClient=new ArrayList<>();
@Override
@Override

case R.id.male:
cl.setSexe("Homme");
break;
case R.id.femelle:
cl.setSexe("Femme");
break;
}
listClient.add(cl);
}
});
}
}
Etape 2 : Ajouter une Liste (ListView)
51 / 98
Le Design :
Activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent"
android:background="@drawable/background7">
<TableLayout
android:id="@+id/infos"
android:layout_alignParentBottom="true">
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<EditText
52 / 98
</TableRow>
<TableRow>
<TextView
<RadioGroup
android:id="@+id/sexes"
<RadioButton
android:id="@+id/homme"
android:text="Homme"
android:checked="true"
<RadioButton
android:id="@+id/femme"
android:text="Femme"
</RadioGroup>
</TableRow>
<Button
android:text="Save"
</TableLayout>
<ListView
android:id="@+id/clients"
android:layout_above="@id/infos"/>
</RelativeLayout>
Nous avons transformé le ConstraintLayout en RelativeLayout.
MainActivity.java
53 / 98
import android.widget.ArrayAdapter;
import android.widget.ListView;
List<Client> listClient=new ArrayList<Client>();

ArrayAdapter<Client> adapter=null;
@Override

adapter=new
ArrayAdapter<Client>(this,android.R.layout.simple_list_item_1,listClient);
@Override

case R.id.homme:
break;
case R.id.femme:
break;
}
listClient.add(cl);
ListView list=(ListView) findViewById(R.id.clients);

list. setAdapter(adapter);
}
});
}
}
54 / 98
Rappel de Cours
L'adaptateur ArrayAdapter
Il s'agit d'une interface (adaptateur) permettant le passage des données à une interface de
sélection telles une ListView ou un Spinner (Combo).
Il suffit de lui passer un tableau ou une instance de java.util.List.
Parmi les constructeurs disponibles, il y a :
public ArrayAdapter (Context context, int textViewResourceId, T[] objects)
public ArrayAdapter (Context context, int textViewResourceId, List<T> objects)
Paramètres:
 Context : Le contexte courant, généralement l'instance de votre activité.

 textViewResourceId : L'identifiant de la ressource de la vue qui recevra les
données "reformatées"
 objects : Les données sous forme de tableau ou une liste des données.
Exemple d'utilisation :
String[] items = {"élément 1", "élément 2 ", "élément 3"};

new ArrayAdapter<String>(this, android.R.layout.votre_widget, items);
Par defaut, ArrayAdapter affiche les données dans le widget en appelant la méthode toString()
pour chaque objet dans la collection et place le résultat dans un TextView.
55 / 98
56 / 98
2 - Manipuler une liste de clients : Menu Principal (Basic Activity).
Nous allons, dans cette partie, créer un projet avec MainActivity comme activité principale et
plusieurs activités :
Etape 1 : Ajouter une Basic Activity (MainActivity)
MainActivity
57 / 98
Menu_main.xml
<menu xmlns:android="http://schemas.android.com/apk/res/android"
tools:context="ma.tdi2.appgestionclient.MainActivity">
<item
android:id="@+id/action1"
android:title="ListViewClient"
app:showAsAction="never" />
<item
android:title="SpinnerClient"
<item
android:title="GridViewClient"
<item
android:title="GridViewClientSaisie"
<item
android:title="Quitter"
</menu>
MainActivity.java
package ma.tdi2.appgestionclient;
import android.view.Menu;
import android.view.MenuItem;
@Override
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);

@Override
public void onClick(View view) {
58 / 98
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
Intent intent = new Intent(this,ListViewClient.class);
}
Intent intent = new Intent(this,SpinnerClient.class);
}
Intent intent = new Intent(this,GridViewClients.class);
}
Intent intent = new Intent(this,GridViewClientSaisie.class);
}
finish();
}
return super.onOptionsItemSelected(item);
}
}
59 / 98
Etape 2 : Ajouter une Basic Activity (ListViewClient)
ListViewClient :
list_view_client.xml

<RelativeLayout
app:layout_behavior="@string/appbar_scrolling_view_behavior"
60 / 98
tools:context="ma.tdi2.appgestionclient.ListViewClient"
tools:showIn="@layout/activity_list_view_client"
<TableLayout
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<RadioGroup
android:layout_height="wrap_content">
<RadioButton
<RadioButton
</RadioGroup>
</TableRow>
61 / 98
<Button
android:text="Save"
</TableLayout>
<ListView
android:id="@+id/clients"
android:layout_alignParentTop="true"
android:layout_above="@id/infos"/>
</RelativeLayout>
Client .java
/**
*/
public class Client {
private String Nom;

private String Prenom;
private String Sexe;
public Client(String nom, String prenom, String sexe) {

Nom = nom;
Prenom = prenom;
Sexe = sexe;
}
public Client() {
Nom = "";
Prenom = "";
Sexe = "";
}

return Nom;
}

Nom = nom;
}
public String getPrenom() {

return Prenom;
}
public void setPrenom(String prenom) {

Prenom = prenom;
}
public String getSexe() {
62 / 98
return Sexe;
}
public void setSexe(String sexe) {

Sexe = sexe;
}
@Override
public String toString() {
return(getNom()+" "+ getPrenom()+" "+getSexe());
}
ListViewClient .java
public class ListViewClient extends AppCompatActivity {

@Override
setContentView(R.layout.activity_list_view_client);
FloatingActionButton fab = (FloatingActionButton)

findViewById(R.id.fab);
@Override
}
});

adapter=new
63 / 98
@Override

case R.id.homme:
break;
case R.id.femme:
break;
}
listClient.add(cl);
ListView list=(ListView) findViewById(R.id.clients);

list. setAdapter(adapter);
});
}
64 / 98
Etape 3 : Ajouter une Basic Activity (SpinnerClient)
SpinnerClient :
Spinner_client.xml

tools:context="ma.tdi2.appgestionclient.SpinnerClient"
tools:showIn="@layout/activity_spinner_client">
<TableLayout
android:layout_alignParentTop="true">
<TableRow>
<TextView
<EditText
65 / 98
</TableRow>
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<RadioGroup
<RadioButton
<RadioButton
</RadioGroup>
</TableRow>
<Button
android:text="Save"
</TableLayout>
<Spinner
android:id="@+id/CboClients"
android:layout_centerVertical="true"
android:layout_height="50dp" />
</RelativeLayout>
66 / 98
SpinnerClient.java
import android.widget.Spinner;
public class SpinnerClient extends AppCompatActivity {

@Override
setContentView(R.layout.activity_spinner_client);
FloatingActionButton fab = (FloatingActionButton)

findViewById(R.id.fab);
@Override
Snackbar.LENGTH_LONG).setAction("Action", null).show();
}
});

adapter=new
@Override

case R.id.homme:
break;
case R.id.femme:
67 / 98
break;
}
listClient.add(cl);
Spinner combo=(Spinner) findViewById(R.id.CboClients);

combo.setAdapter(adapter);
}
});
}
68 / 98
Etape 4 : Ajouter une Basic Activity (GridViewClient)
GridViewClient
Gridview_client.xml

tools:context="ma.tdi2.appgestionclient.GridViewClients"
tools:showIn="@layout/activity_grid_view_clients">
<TableLayout
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
69 / 98
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<RadioGroup
<RadioButton
<RadioButton
</RadioGroup>
</TableRow>
<Button
android:text="Save"
</TableLayout>
<GridView
android:id="@+id/gv"
android:listSelector="@android:color/holo_orange_dark"
android:background="@android:color/holo_blue_dark"
android:numColumns="3" />
</RelativeLayout>
70 / 98
GridViewClient.java
import android.widget.AdapterView;
import android.widget.GridView;
import android.widget.Toast;
import java.util.ListIterator;
public class GridViewClients extends AppCompatActivity {
ArrayList<Client> listClient = new ArrayList<>();

ArrayAdapter<String> adapter=null;
String[] T; // = {"A","B","C","D","E","F","G","H","I"};;
GridView gv;
@Override
setContentView(R.layout.activity_grid_view_clients);

@Override
}
});
listClient.add(new Client("Alami","Khalid","Homme"));
listClient.add(new Client("Wahbi","Rachid","Homme"));
listClient.add(new Client("Naji","Sanae","Femme"));
listClient.add(new Client("Talbi","Aicha","Femme"));
gv=(GridView) findViewById(R.id.gv);
//adapter = new
71 / 98
ArrayAdapter<String>(getApplicationContext(),android.R.layout.simple_list_item_1,T)
;
final String T[] = new String[3*listClient.size()];
for(int i =0;i<listClient.size();i++){
T[3*i] = listClient.get(i).getNom();
T[3*i+1] = listClient.get(i).getPrenom();
T[3*i+2] = listClient.get(i).getSexe();
}
//Toast.makeText(getApplicationContext(),listClient.get(0).getNom(),Toast.LENGTH_LO
NG).show();
// gv=(GridView) findViewById(R.id.gv);
adapter = new
ArrayAdapter<String>(getApplicationContext(),android.R.layout.simple_list_item_1,T)
;
gv.setAdapter(adapter);
gv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position,
long id) {

nom.setText(T[position]);
prenom.setText(T[position+1]);
if (T[position+2] == "Homme"){
RadioButton homme = (RadioButton) findViewById(R.id.homme);
homme.setChecked(true);
}
else {
RadioButton femme = (RadioButton) findViewById(R.id.femme);
femme.setChecked(true);
}
}
});
72 / 98
73 / 98
74 / 98
Etape 4 : Ajouter une Basic Activity (GridViewClientSaisie)
GridViewClientSaisie :

tools:context="ma.tdi2.appgestionclient.GridViewClientSaisie"
tools:showIn="@layout/activity_grid_view_client_saisie"
<TableLayout
android:layout_alignParentBottom="true"
android:stretchColumns="1">
<TableRow>
<TextView
<EditText
75 / 98
</TableRow>
<TableRow>
<TextView
<EditText
</TableRow>
<TableRow>
<TextView
<RadioGroup
<RadioButton
<RadioButton
</RadioGroup>
</TableRow>
<Button
android:text="Save"
</TableLayout>
<GridView
android:id="@+id/gv"
android:background="@android:color/holo_blue_dark"
android:numColumns="3" />
</RelativeLayout>
76 / 98
GridViewClientSaisie.java
import android.widget.GridView;
public class GridViewClientSaisie extends AppCompatActivity {
ArrayList<Client> listClient = new ArrayList<>();

ArrayAdapter<String> adapter=null;
String[] T; // = {"A","B","C","D","E","F","G","H","I"};;
GridView gv;
@Override
setContentView(R.layout.activity_grid_view_client_saisie);

@Override
}
});
@Override

case R.id.homme:
break;
case R.id.femme:
77 / 98
break;
}
listClient.add(cl);
String T[] = new String[3*listClient.size()];
for(int i =0;i<listClient.size();i++){
T[3*i] = listClient.get(i).getNom();
T[3*i+1] = listClient.get(i).getPrenom();
T[3*i+2] = listClient.get(i).getSexe();
}
//Toast.makeText(getApplicationContext(),listClient.get(0).getNom(),Toast.LENGTH_
LONG).show();
gv=(GridView) findViewById(R.id.gv);
adapter = new
ArrayAdapter<String>(getApplicationContext(),android.R.layout.simple_list_item_1,
T);
gv.setAdapter(adapter);
}
});
}
}
78 / 98
3 – SQLite : Accès aux BDs android avec SQLite.
Nous allons, dans cette partie, créer un projet avec MainActivity :

<RelativeLayout
tools:context="ma.tdi2.testbd.MainActivity">
<LinearLayout
android:orientation="vertical">
<LinearLayout
android:orientation="horizontal">
<TextView
android:layout_weight="1"
android:text="id :"
<EditText
android:id="@+id/id_Cl"
79 / 98
</LinearLayout>
<LinearLayout
<TextView
<EditText
</LinearLayout>
<LinearLayout
<TextView
android:text="Ville :"
<EditText
android:id="@+id/ville"
</LinearLayout>
<LinearLayout
<Button
android:text="Save"
android:textAlignment="center"
android:textAllCaps="false"
</LinearLayout>
<Button
80 / 98
android:id="@+id/display"
android:layout_gravity="center"
android:layout_weight="0.59"
android:text="Display"
<Button
android:id="@+id/vider"
android:text="Vider"
android:textAlignment="center"
</LinearLayout>
</RelativeLayout>
La classe VenteDatabaseHelper.java
package ma.tdi2.test_bd;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
/**
*/
public class VenteDatabaseHelper extends SQLiteOpenHelper {
// Database and Table Info

private static final String DATABASE_NAME = "Vente";
private static final String TABLE_Client = "Client";
// Client Table Columns

private static final String COL_1 = "id_Cl";
private static final String COL_2 = "Nom";
private static final String COL_3 = "Ville";
public VenteDatabaseHelper(Context context) {

super(context, DATABASE_NAME, null, 1);
// Ceci pour créer la BD
SQLiteDatabase db = getWritableDatabase();
81 / 98
}
@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_TABLE_Client = "CREATE TABLE " + TABLE_Client +

"(" +
COL_1 + " INTEGER PRIMARY KEY," +
COL_2 + " TEXT," +
COL_3 + " TEXT" +
")";
db.execSQL(CREATE_TABLE_Client);
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
db.execSQL("DROP TABLE IF EXISTS " + TABLE_Client);

onCreate(db);
// Insert a client into the database

public void addClient(Client client) {
// Create and/or open the database for writing
ContentValues values = new ContentValues();

values.put(COL_1, client.getId_Cl());
values.put(COL_2, client.getNom());
values.put(COL_3, client.getVille());
db.insert(TABLE_Client, null, values);

db.close();
}
public List<Client> getAllData() {

List<Client> listeClient = new ArrayList<Client>();
String CLIENTS_SELECT_QUERY = "SELECT * FROM " + TABLE_Client;
SQLiteDatabase db = getReadableDatabase();
Cursor cursor = db.rawQuery(CLIENTS_SELECT_QUERY, null);
if (cursor.moveToFirst()) {
do {

cl.id_Cl =
Integer.parseInt(cursor.getString(cursor.getColumnIndex(COL_1)));
cl.Nom = cursor.getString(cursor.getColumnIndex(COL_2));
cl.Ville = cursor.getString(cursor.getColumnIndex(COL_3));
listeClient.add(cl);
} while(cursor.moveToNext());
}
db.close();
return listeClient;
}
82 / 98
public void UpdateClient(Client client) {
ContentValues values = new ContentValues();

values.put(COL_2, client.getNom());
values.put(COL_3, client.getVille());
// Updating profile picture url for user with that userName

db.update(TABLE_Client, values, COL_1 + " = ?",
new String[] { String.valueOf(client.getId_Cl()) });
db.close();
}
public void deleteClient(int id) {

db.delete(TABLE_Client,"id_Cl=?",new String[]{String.valueOf(id)});
//db.execSQL("Delete From " + TABLE_Client + " Where id_Cl = " +
String.valueOf(id));
db.close();
}
public void EmptyClient()

{
db.execSQL("Delete From " + TABLE_Client);
//db.delete(TABLE_Client, null, null);
db.close();
}
}
La classe Client.java
public class Client {
public int id_Cl;

public String Nom;
public String Ville;
public Client(int id_Cl, String nom, String ville) {

this.id_Cl = id_Cl;
Nom = nom;
Ville = ville;
}
83 / 98
public Client() {
this.id_Cl = 0;
Nom = "";
Ville = "";
}
public int getId_Cl() {

return id_Cl;
}
public void setId_Cl(int id_Cl) {

this.id_Cl = id_Cl;
}

return Nom;
}

Nom = nom;
}
public String getVille() {

return Ville;
}
public void setVille(String ville) {

Ville = ville;
}
}
84 / 98
4 – Utilisation de Lineaire Layout pour créer un formuaire de mise à jour de
la table client.
85 / 98
I – 6 Exercices :
Exercice 1 :
Exercice 2 :
Exercice 3 :
Lexique
Concepts de base
Dans ce premier article consacré au développement d'une application sous Android, on abordera
les fondamenteaux de ce domaine. On expliquera ce qui est Context, Intent, Bundle et Activity.
Cette dernière notion est sans doute la plus importante. On verra pourquoi plus loin.
Qu'est-ce que c'est Activity sous Android ?
Activity peut être traduit en mot "activité". En analogie avec le monde des applications web, on peut dire qu'elle
est une page web. Elle représente une chose que l'utilisateur peut faire à un moment donné.
86 / 98
Les activités sont gérées dans une pile d'activités. Chaque fois où une nouvelle activité est lancée, elle arrive à
la première position de la pile et devient l'activité qui est actuellement exécutée. L'activité précédente reste
dans la pile et ne pourra pas être lancée une fois la première activitée terminée.
L'activité est représentée par la classe Activity dont 7 méthodes illustrent le cycle de vie qu'elle peut prendre :
- onCreate : la méthode d'initialisation des vues, des paramètres et d'autres données. Elle prend en paramètre
l'instance de la classe Bundle qu'on présentera plus loin dans l'article.
- onStart : appelée quand l'activité est rendue visible à l'utilisateur.
- onRestart : appelée à un nouveau démarrage de la même activité (quand l'activité était arrêtée)
- onResume : appelée quand l'activité commence à interagir avec l'utilisateur.
- onPause : méthode qui sert à arrêter une activité temporairement.
- onStop : cette fonction est utilisée quand l'activité n'est plus visible à l'utilisateur. Elle est cachée soit à cause
d'une nouvelle activité lancée, soit parce que l'activité en cours s'apprête à être détruite.
- onDestroy : est invoquée quand l'activité est détruite. La destruction opère quand quelqu'un appele la
méthode finish() ou quand c'est le système qui décide de tuer l'activité pour économiser de l'espace.
TODO : présenter d'une manière plus interactive
Qu'est-ce que c'est Bundle sous Android ?
Dans le paragraphe précédent on a mentionné l'existence d'un paramètre passé à la méthode onCreate. Il
s'agitssait de l'instance de la classe Bundle.
Cette classe est une sorte de conteneur pour les données transmissibles d'une activité à l'autre. Elle permet de
récupérer tout type de données : long, char, ArrayList ...
Mais attention, c'est une des 2 méthodes de transmission de données. L'autre se base sur les données stockées
dans des intentions.
Qu'est-ce que c'est Intent sous Android ?
Les intentions sont des opérations qui permettent, entre autres, de naviguer entre les écrans. Grâce à elles on
peut également passer des paramètres d'un écran à l'autre de notre application. C'est d'ailleurs cette méthode
de passage qu'on utilisera dans notre exemple d'application développée sous Android.
Cependant, la navigation n'est pas la seule fonctionnalité des intentions. L'autre, aussi importante, est la
possibilité d'écouter et de réagir à des événements extérieurs à l'application. Par exemple, grâce à des
intentions, on peut capter le moment où notre connexion WiFi n'est plus disponible et exécuter une action dans
notre application. On utilisera pour cela les broadcast receivers sous Android, qu'on abordera plus loin dans la
série.
Une intention est donc définie par :
- une liste d'événements auxquels elle doit répondre
- un composant de l'application qui doit s'occuper de gérer l'événement capté
On distingue deux type d'intentions :
- explicite : on sait quelle activité on veut démarrer (par exemple pour passer à une activité "ShowSite" après le
click sur le bouton "afficher le site")
- implicite : on ne sait pas quelle activité doit être invoquée. En occurrence, c'est Android qui va se charger de
trouver l'activité adéquate à lancer (par exemple pour consulter un site web, il va lancer un des navigateurs
disponibles).
Les intentions sont accompagnés de filtres. Ils regroupent des conditions que doit remplir une activité ou un
broadcast receiver pour être exécuté.
Qu'est-ce que c'est Context sous Android ?
Essentiellement, un Context est une référence à des ressources gérées par l'application. Il permet également de
récupérer les informations sur le système. Il fournit aussi l'accès à des services de l'Android.
Le contexte permet aussi de gérer d'autres aspects de l'application. Il doit d'ailleurs être employé pour pouvoir
lancer une nouvelle activité, réceptionner les intentions ou écouter les événements. Voici les exemples plus
précis :
- création de nouveaux objets (TextView, Adapter...)
- accès à des ressources (String, Array...)
- accès implicit à des components (par
exemple getApplicationContext().getContentResolver()pour content resolver)
87 / 98
Comment récupérer le contexte ? Une des 4 méthodes le permet :
- getApplicationContext()
- getContext()
- getBaseContext()
- this - mais disponible uniquement quand on récupère le contexte depuis une activité
Qu'est-ce que c'est Service sous Android ?
Dans la définition du contexte, on a abordé l'existence des services. Les services sont des tâches qui peuvent
être lancées avec ou sans intervention de l'utilisateur. Elles s'exécutent dans le background de l'application et
peuvent se terminer soit après la finalisation de la tâche, soit à travers une intervention externe. Les services
représentent également une fonctionnalité d'une application exposée à d'autres applications. Il est important de
mentionner que le service ne fournit pas d'interface graphique (User Interface).
Un service concret hérite de la classe Service et surcharge des méthodes suivantes :
- onStartCommand : si un autre component (par exemple une activité) fait appel à un service
via startService(), c'est la méthode onStartCommande du service qui est appelée en premier.
- onBind : pareil qu'onStartCommand. La seule différence repose dans le fait que cette méthode est appelée
quand un autre component appelle le service avec bindService(). onBind doit retourner nullsi l'on souhaite que
l'invocation du service depuis une autre application soit impossible.
- onCreate : elle est appelée après onStartCommand ou onBind. Cette méthode contient toutes les procédures
nécessaires à l'initialisation du service.
- onDestroy : cette fonction est invoquée quand l'exécution du service doit être terminée. L'implémentation de
cette méthode est nécessaire car chaque fin de l'exécution libère des ressources de l'Android.
Qu'est-ce que c'est Broadcast Receiver sous Android ?
A l'ocassion du chapitre consacré à des intentions on a brièvement présenté les broadcast receivers. Ici, on les
développera un peu plus. Pour commencer, quelle définition on pourrait donner à des broadcast receivers ? Ce
sont des classes implémentant BroadcastReceiver qui reçoivent des intentions et effectuent des actions
spécifiques.
Ils vivent uniquement le temps qui est nécessaire pour traiter l'intention. Le traitement s'effectue dans la
méthode onReceive() qui prend en paramètre les instances du Context et de l'Intent.
Les broadcast receivers sont destinés à exécuter de petites tâches, comme l'envoi d'une nouvelle localisation
GPS, traitement rapide d'un mail envoyé. Android attribue à des broadcast receivers un laps de temps (10
seconds) dans lequel la tâche définie doit être terminée. Si au bout de ce temps le traitement n'est pas terminé,
le broadcast receiver est immédiatement disponible à être tué si l'application a besoin de plus de mémoire.
Donc, ils ne sont pas adaptés à des tâches dont la durée est indéterminée ou très longue (plus que 10
seconds). Dans ce cas de figure on utilisera la conjonction du Service à broadcast receiver.
Qu'est-ce que c'est Content Provider sous Android ?
Certaines données d'une application doivent être partagées avec d'autres application. C'est le cas par exemple
d'un carnet d'adresses qui peut être facilement utilisée par d'autres application pour pouvoir, par exemple,
envoyer un SMS à un de ses contacts. Sous le principe de partage se cache la notion du Content Provider.
L'accès à ces données se fait via l'instance de la classe ContentResolver. Elle permet d'effectuer toutes les
opérations CRUD (create, retreive, update, delete).
Dans cette partie on a vu les fondamentaux d'une application Android. Les chapitres suivants les présenteront
plus en détail et, surtout, plus en pratique.
88 / 98
Cod en Vrac :
89 / 98
90 / 98
91 / 98
How to bind ArrayList Objects to android GridView?
GridView settingGrid;
ArrayList<Person> persons;
92 / 98
public void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.setting);
persons =new ArrayList<Person>();
settingGrid = (GridView)findViewById(R.id.settinggridview);
settingGrid.setAdapter(new SettingImageAdapter(this));
settingGrid.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView parent, View v, int position,long id) {
});
public class SettingImageAdapter extends BaseAdapter{

Context MyContext;
public SettingImageAdapter(Context _MyContext){

MyContext = _MyContext;
}
public int getCount() {

return persons.size();
}
public View getView(int position, View convertView, ViewGroup parent) {

View v;
if(convertView==null){
LayoutInflater li = getLayoutInflater();
v = li.inflate(R.layout.setting_gried_item, null);
TextView tv = (TextView)v.findViewById(R.id.grid_item_text);
tv.setText("Profile "+position);
tv.setText(persons.get(position));
}
else
{
v = convertView;
}
return v;
}
public Object getItem(int arg0) {

return null;
}
public long getItemId(int arg0) {

return 0;
}
// references to our images

private Integer[] mThumbIds = {
R.drawable.one, R.drawable.two,
R.drawable.five, R.drawable.four,
R.drawable.eight,R.drawable.seven,
R.drawable.seven
};
private String[] names = {
"Wallpaper Setting","Font Setting",
"Sysnchronization Download","Sysnchronization Upload",
"Change Password","Camera",
"Gallery"
};
}
93 / 98
And your XML like be :

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/GridItem"
android:orientation="vertical"
android:gravity="center_horizontal"
android:layout_x="201px"
android:layout_y="165px" >
<TextView android:id="@+id/grid_item_text"
android:text="TextView"
android:gravity="center_horizontal"
android:textColor="#000000">
</TextView>
</LinearLayout>
This is setting.xml
<GridView xmlns:android="http://schemas.android.com/apk/res/android"
android:background="@drawable/wallpaper"
android:id="@+id/settinggridview"
android:layout_height="fill_parent"
android:numColumns="auto_fit"
android:textFilterEnabled="true"
android:stretchMode="columnWidth"
android:gravity="center"
android:horizontalSpacing="15px"
android:verticalSpacing="25px"
>
94 / 98
What does android:layout_weight mean?
With layout_weight you can specify a size ratio between multiple views. E.g. you have
a MapViewand a table which should show some additional information to the map. The map should
use 3/4 of the screen and table should use 1/4 of the screen. Then you will set
the layout_weight of the mapto 3 and the layout_weight of the table to 1.
If there are multiple views spanning a LinearLayout, then layout_weight gives them each a proportional
size. A view with a bigger layout_weight value "weighs" more, so it gets a bigger space.
Here is an image to make things more clear.
Theory
The term layout weight is related to the concept of weighted average in math. It is like in a college
class where homework is worth 30%, attendance is worth 10%, the midterm is worth 20%, and the
final is worth 40%. Your scores for those parts, when weighted together, give you your total grade.
It is the same for layout weight. The Views in a horizontal LinearLayout can each take up a certain
percentage of the total width. (Or a percentage of the height for a vertical LinearLayout.)
The Layout
95 / 98
The LinearLayout that you use will look something like this:
<LinearLayout

</LinearLayout>
Note that you must use layout_width="match_parent" for the LinearLayout. If you use wrap_content,
then it won't work. Also note that layout_weight does not work for the views in RelativeLayouts
(see here and here for SO answers dealing with this issue).
The Views
Each view in a horizontal LinearLayout looks something like this:
<Button
android:layout_weight="1" />
Note that you need to use layout_width="0dp" together with layout_weight="1". Forgetting this
causes many new users problems. (See this article for different results you can get by not setting
the width to 0.) If your views are in a vertical LinearLayout then you would
use layout_height="0dp", of course.
In the Button example above I set the weight to 1, but you can use any number. It is only the total
that matters. You can see in the three rows of buttons in the first image that I posted, the numbers
are all different, but since the proportions are the same, the weighted widths don't change in each
row. Some people like to use decimal numbers that have a sum of 1 so that in a complex layout it
is clear what the weight of each part is.
One final note. If you have lots of nested layouts that use layout_weight, it can be bad for
performance.
Extra
Here is the xml layout for the top image:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
<TextView
android:text="android:layout_weight="
<LinearLayout
<Button
android:text="1" />
<Button
96 / 98
android:text="2" />
<Button
android:text="1" />
</LinearLayout>
<TextView
<LinearLayout
<Button
android:text="10" />
<Button
<Button
</LinearLayout>
<TextView
<LinearLayout
<Button
android:layout_weight=".25"
android:text=".25" />
<Button
97 / 98
<Button
</LinearLayout>
</LinearLayout>
layout_weight tells Android how to distribute your Views in a LinearLayout. Android then first
calculates the total proportion required for all Views that have a weight specified and places
each View according to what fraction of the screen it has specified it needs. In the following
example, Android sees that the TextViews have a layout_weight of 0 (this is the default) and
the EditTexts have a layout_weight of 2 each, while the Button has a weight of 1. So Android
allocates 'just enough' space to display tvUsername and tvPassword and then divides the remainder
of the screen width into 5 equal parts, two of which are allocated to etUsername, two
to etPassword and the last part to bLogin:
<LinearLayout android:orientation="horizontal" ...>
<TextView android:id="@+id/tvUsername"
android:text="Username"
android:layout_width="wrap_content" ... />
<EditText android:id="@+id/etUsername"
android:layout_weight="2" ... />
<TextView android:id="@+id/tvPassword"
android:text="Password"
android:layout_width="wrap_content" />
<EditText android:id="@+id/etPassword"
android:layout_weight="2" ... />
<Button android:id="@+id/bLogin"
android:text="Login"... />
</LinearLayout>
It looks like:
And
98 / 98
Think it that way, will be simpler
If you have 3 buttons and their weights are 1,3,1 accordingly, it will work like table in HTML
Provide 5 portions for that line: 1 portion for button 1, 3 portion for button 2 and 1 portion for button 1
Regard,
One of the best explanations for me was this one (from the Android tutorial, look for step 7):
layout_weight is used in LinearLayouts to assign "importance" to Views within the layout. All Views have a
default layout_weight of zero, meaning they take up only as much room on the screen as they need to be
displayed. Assigning a value higher than zero will split up the rest of the available space in the parent View,
according to the value of each View's layout_weight and its ratio to the overall layout_weight specified in the
current layout for this and other View elements.
To give an example: let's say we have a text label and two text edit elements in a horizontal row. The label
has no layout_weight specified, so it takes up the minimum space required to render. If the layout_weight of
each of the two text edit elements is set to 1, the remaining width in the parent layout will be split equally
between them (because we claim they are equally important). If the first one has a layout_weight of 1 and the
second has a layout_weight of 2, then one third of the remaining space will be given to the first, and two
thirds to the second (because we claim the second one is more important).
99 / 98

Module 12 - Développement D - Applications Mobiles

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Module 12 - Développement D - Applications Mobiles

Transféré par

Droits d'auteur :

Formats disponibles

ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

Développement d'applications mobiles

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

Technicien en Techniques de Développement Informatique

Guide des travaux pratiques

Développement d'applications mobiles

I - Installation et configuration des outils

 RAM 4 Go (fonctionnement lourd). 8 Go recommandé.

 Pour Windows : Windows Vista ou plus récent.

3 – Le Java Development Kit (JDK)

Il existe deux plateformes en Java :

4 – Téléchargement et installation du JDK :

Voici le lien de téléchargement :

Cliquez sur Download en dessous de JDK :

Choisissez ensuite la version adaptée à votre configuration. Une fois le téléchargement

5 – Téléchargement et installation d’Android Studio et le SDK Android :

On va maintenant télécharger un pack (fichier) qui contient Android Studio et un outil

Android Studio est un environnement de développement (EDI) spécialisé dans le

Voici le lien de téléchargement :

Cliquez sur Download Android Studio pour démarrer le téléchargement :

Un SDK, un kit de développement, est un ensemble d'outils permettant de développer pour un

5 – Création de votre premier projet :

Cliquez sur Start a new Android Studio Project

Une nouvelle fenêtre s'ouvrira. Elle contient trois champs :

C’est la première étape de création d'un projet

 Company Domain : c’est le nom de domaine de votre entreprise (Exemple :

Cliquez sur Next pour passer à l'écran suivant.

Cet écran vous permet de sélectionner le matériel de destination de votre application,

Une fois votre sélection faites, cliquez sur Next.

Sélectionnez Empty Activity et cliquez sur Next.

Ce sont des informations sur la première activité de notre application.

Cliquez juste sur Finish .

II – Configuration du téléphone (Appareil réel).

 Activer l'option Débogage USB

Si Options de développement n’apparait pas allez dans :

III – Création d’une machine virtuelle.

1 - Qu'est-ce qu'une activité ?

Si vous observez l’architecture de la majorité des applications Android, vous

En cliquant sur un élément de la liste à gauche, on ouvre une nouvelle activité.

2 - États d'une activité

Une activité peut se trouver dans les trois états suivants :

3 - Cycle de vie d'une activité

Qui peut être représenté aussi de la manière suivante :

 Created : l’activité a été créée et prête à être affiché.

 Destroyed : l’activité est détruite par le système et n’existe plus.

Les activités héritent de la classe Activity.

Un package = un espace de nom.

4 - Création d’une machine virtuelle (ou émulateur).

 Ou bien Cliquez sur l’icône :

Cliquez sur le bouton Create Virtual Device en bas de l'écran :

 Cliquer sur Finish directement.

Notre machine virtuelle a été créée avec succès.

 Choisisser New Project :

Le Manifeste : AndroidManifest.xml (ensemble d’informations sur l’application).

MainActivity (Class Java)

L’application est bien installée dans l’émulateur :

 Choisisser New Project :

MainActivity contient les Views (Widgets) suivants :

 Choisisser New Project :

MainActivity contient les Views (Widgets) suivants :

public class MainActivity extends AppCompatActivity {

btnClick = (Button) findViewById(R.id.buttonClick);