Plycopie Java Mobile Final

Module : Systèmes embarqués 2 et
Java mobile
Elément : Java mobile
Pr. Fouad AYTOUNA
Année Universitaire 2019-2020

Université Abdelmalek Essaadi
ENSA-Tétouan /GSTR
Pr. Fouad AYTOUNA Java Mobile 1

ENSA-Tétouan /GSTR
Chapitre 1
Présentation générale

ENSA-Tétouan /GSTR
Table des matières
I. Développement mobile ............................................................................................ 4
II. Les principaux OS mobiles .................................................................................. 4
III. Présentation Android ............................................................................................ 4
IV. Les versions de l’Android .................................................................................... 5
V. Google play .......................................................................................................... 5
VI. Architecture Android ............................................................................................ 6
VII. Dalvik et ART ...................................................................................................... 6
VIII. SDK Android........................................................................................................ 6
IX. Compilation et déploiement ................................................................................. 6
X. Android Studio ..................................................................................................... 7
Présentation .................................................................................................................... 7
AVD: le gestionnaire d'appareils .................................................................................... 7
XI. Structure projet Android ....................................................................................... 7
Les ressources ................................................................................................................. 7
Le fichier manifest.xml .................................................................................................. 7
Les packages ................................................................................................................... 8

ENSA-Tétouan /GSTR
I. Développement mobile
Le temps passé sur l'écran de son mobile est de plus en plus important. Selon une étude de TNS
Sofres, les Francais de 16-30 ans sont concentrés sur leur téléphone mobile plus de deux heures
par jour.
Aujourd'hui, il est nécessaire pour chaque entreprise faut d'intégrer le mobile dans sa stratégie
digitale.
Pour intégrer le mobile, il existe trois solutions :
 Développer une application native : Une application native est un "logiciel" que l'on
télécharge et que l'on installe sur son smartphone ou sur sa tablette via des plateformes
d'applications (applestore, googleplay, marketplace). Cette application est développée
pour un des systèmes d'exploitation utilisé par les smartphones ou tablettes (Android pour
Google, IOS pour iphone ou Windowsphone pour Microsoft). Elle est développée avec
un language spécifiques aux différents systèmes d'exploitation (type java pour android).
Si vous souhaitez que votre application mobile soit disponible sur les deux principales
plateformes AppleStore et googleplay, vous devrez développer deux applications
distinctes. Il faut une application par système d'exploitation afin que les interfaces et les
usages soient respectés. Ce qui implique un budget conséquent.
 Développer une webapplication : Une webapplication (ou webapp), est une application
mobile exécutable via le navigateur internet de votre smartphone. C'est en quelque sorte
"un site internet spécialement conçu pour votre mobile".
 Développer une application hybride : Le développement d'une application hybride est
un mix des deux premières solutions: applications natives et webapplications. Elle
combine des éléments HTML5 sous forme de webapplication et des éléments de
l'application native.Le développement d'application hybride repose sur des solutions
comme phonegap/Cordova, qui permettent de créer une application indépendante à partir
de pages webs. Elle permet d'utiliser les fonctions du téléphone et elle est téléchargeables
sur les plateformes apple store, googleplay.
II. Les principaux OS mobiles
• Android (google, …)
• Iphone OS (Apple) sur des téléphones IPhone et sur les tablettes d'Apple
• Windows Mobile (Microsoft) ; système propriétaire
• Symbian (Nokia) ; récemment passé en open source
• BlackBerry OS. Présent sur tous les téléphones de la marque RIM (Research In
Motion) ;
• Palm Web OS (successeur de Palm Os)
•LiMo (Linux Mobile),système ouvert basé sur Linux
(http://www.tizenassociation.org/en/)
• MeeGo, Intel et Nokia (https://meego.com/)
• Bada, Samsung (http://www.bada.com/whatisbada/index.html
III. Présentation Android
Android doit son nom à la startup éponyme spécialisée dans le développement d’applications
mobiles rachetée par Google en août 2005, nom venant lui-même d'« androïde » qui désigne un
robot construit à l'image d'un être humain.
Lancé en juin 2007 à la suite du rachat par Google en 2005 de la startup du même nom, le
système avait d'abord été conçu pour les smartphones et tablettes tactiles, puis s'est diversifié
dans les objets connectés et ordinateurs comme :

ENSA-Tétouan /GSTR
- Les télévisions (Android TV)

- Les voitures (Android Auto)
- Les ordinateurs (Android-x86)
- Les smartwatch (Android Wear).
Android est un système d'exploitation mobile, c'est-à-dire que, tout comme Windows ou
Linux c'est un gros programme, composé de petits programmes, qui permet d'exécuter d'autres
logiciels. Par exemple, Windows permet d'exécuter Internet Explorer, et pour ce faire, il doit
faire le lien entre la souris et le curseur à l'écran, entre le clavier et les champs de saisie, etc.
Avec l'explosion des ventes de smartphones ces dernières années, Android a pris une place
importante dans la vie quotidienne de millions de personnes, au point qu'il s'agit du système
d'exploitation mobile avec le plus d'applications en circulation.
IV. Les versions de l’Android
V. Google play
Google Play (Play Store), est une boutique en ligne créée par Google (le 6 mars 2012) par fusion
des services Android Market et d'autres services Google (location de films, achat de musique,
etc.). Elle permet de télécharger et d'installer de nouvelles applications ("apps") dans le
smartphone.
Android market est "né" le 22 octobre 2008 ".
Au 30 octobre 2012, Google Play est fort de 700 000 applications ce qui le met à égalité avec
iOS" : voir historique à http://fr.wikipedia.org/wiki/Android_Market.
Les développeurs d'applications payantes reçoivent 70 % du prix du logiciel, 30 % allant à
Google Chaque nouveau développeur paie $25 comme frais de dossier (une seule fois).

ENSA-Tétouan /GSTR
VI. Architecture Android
 Applications - Le projet Open Source Android contient plusieurs applications par défaut
comme le navigateur, l'appareil photo, la galerie, la musique, le téléphone et plus encore ;
 Application Framework - Une API qui permet aux applications Android d'interagir avec
le système Android ;
 Libraries and runtime - Les bibliothèques pour de nombreuses fonctions communes
(par exemple : le rendu graphique, le stockage de données, la navigation sur le Web, etc.)
de l'Application Framework et du moteur Dalvik, ainsi que le noyau de bibliothèques
Java pour exécuter des applications Android ;
 Linux kernel - La couche de communication avec le matériel sous-jacent.
VII. Dalvik et ART

Dalvik et ART sont des machines virtuelles, c'est-à-dire des émulateurs, qui permettent aux
applications de tourner sur des appareils, indépendamment des différences matérielles. En
d'autres termes, Dalvik et ART permettent de faire tourner les applications sur différents
smartphones Android, quel que soit le modèle. Dalvik a été développé notamment pour
permettre aux appareils peu puissants de faire tourner plusieurs applications simultanément.
La mise à jour à venir Android 5.0 Lollipop annoncera la mort de la machine virtuelle Dalvik.
VIII. SDK Android

Le Kit de développement logiciel Android (Android SDK) contient les outils nécessaires pour
créer, compiler et déployer les applications Android. La plupart de ces outils sont en ligne de
commande. Le principal moyen de développer des applications Android est d'utiliser le langage
de programmation Java.
IX. Compilation et déploiement

ENSA-Tétouan /GSTR
X. Android Studio
1. Présentation
Android Studio est un environnement de développement pour développer des applications
Android. Il est basé sur IntelliJ IDEA.
Avant Android Studio, de 2009 à 2014, Google propose comme environnement de
développement officiel une distribution spécifique de l'environnement Eclipse, contenant
notamment le SDK d'Android.
2. AVD: le gestionnaire d'appareils

Pour tester une application, Google fournit un émulateur Android, abrégé par AVD pour Android
Virtual Device.
XI. Structure projet Android

1. Les ressources
Les ressources, éléments indispensables à l’élaboration d’un projet Android, qui comprennent
entre autres, les layouts et menus, les variables, les images (icônes, etc), les couleurs, les styles,
les thèmes, nécessitent eux aussi qu’on applique certaines bonnes pratiques. Toutes vos
ressources sont à stocker dans le répertoire res/, à savoir que différents répertoires sont créés de
base, tels que :
 res/layout/ : comprendra tous vos fichiers XML correspondant à vos layouts,

 res/menu/ : pour stocker vos menus au format XML,
 res/drawable/ : pour toutes vos images,
 res/values/colors : pour toutes les couleurs que vous utilisez dans votre projet,
 res/values/dimens : pour toutes les dimensions de vos éléments,
 res/values/strings : pour toutes les variables de votre application,
 res/values/styles : pour les différents styles de votre application.
2. Le fichier manifest.xml
Nomme le paquetage Java de l'application. Ce dernier sert d'identificateur unique de
l'application.
Déclare les composants applicatifs (activities, services, broadcast receivers, content providers) de
l'application et leurs filtres si nécessaire (à quels intents ils réagissent)
Déclare les permissions que l'application doit avoir pour fonctionner (droit de passer des appels,
droit d'accéder à Internet, droit d'accéder au GPS...)

ENSA-Tétouan /GSTR
Déclare le niveau minimum de compatibilité du SDK pour que l'application fonctionne.

3. Les packages
Contient les sources java de l’application.

ENSA-Tétouan /GSTR
Chapitre 2
Les composants de base de

l’Android
- Partie 1-

ENSA-Tétouan /GSTR
Table des matières

I. Les annonces Toast ................................................................................................ 11
II. TextView................................................................................................................ 11
1. Exercice d’application : ...................................................................................... 12
III. EditText .............................................................................................................. 12
2. Exercice d’application ........................................................................................ 13
IV. Button ................................................................................................................. 14
3. Exercices d’application : .................................................................................... 15

ENSA-Tétouan /GSTR
I. Les annonces Toast

Un «toast» est un message apparaissant en bas d’écran pendant un instant, par exemple pour
confirmer la réalisation d’une action.
Un toast n’affiche aucun bouton et n’est pas actif. Voici comment l’afficher avec une ressource
chaîne
Toast.makeText(this,"Premier Message",Toast.LENGTH_SHORT).show();
 Le premier paramètre représente l’activité courante.

 Le deuxième paramètre est le texte de message à afficher.
 Le dernier paramètre indique la durée d'affichage les seules valeurs possibles sont :
Toast.LENGTH_SHORT (2 secondes) ou Toast.LENGTH_LONG (5 secondes).
Exemple 1 : Au chargement de l’écran un message sera affiché.

Le fichier MainActivity.java et le résultat de ce programme sont montrés ci-après.
package com.example.dell.exemple01_toast;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toast.makeText(this,"Premier Message",Toast.LENGTH_SHORT).show();
}
}
II. TextView
Un TextView peut être défini comme un titre ou bien un paragraphe se situant à l'intérieur d'une
page d'une application mobile Android.
Un TexTview est utilisé pour afficher sur une page une information à un utilisateur. Cela vous
permet de mettre de plus un titre à des images ou des descriptions.
Les principaux attributs de ce composant sont :
Attribut Description
android:id Identifiant du contrôle. Il doit être unique dans
le l’activité.
android:text Le texte qui sera affiche dans le contrôle.
android:textcolor La couleur du texte du contrôle
android:textSize La taille du texte
android:textStyle Cet attribut peut contenir les valeurs suivantes :
0 : normal

ENSA-Tétouan /GSTR
1 : Bold
2 : Italic
Android :textalign Alignement du texte : center ; TextStart ;
TextEnd
Voici un exemple d’accès à un TextView en utilisant le code JAVA. Le TextView posséde le

code t1.
TextView t;
@Override
t = (TextView)findViewById(R.id.t1);
t.setText("TDI - Module de développement");
t.setTextColor(Color.GREEN);
t.setBackgroundColor(Color.GRAY);
…
}
}
Exercice d’application
1. Créer un nouveau projet sous android studio.
2. Dans le code XML de l’activité, modifier le type de layout en
LinearLayout.
3. Ajouter l’attribut Orientation = Verticale aux attributs de
LinearLayout.
4. Construire l’interface suivante :
5. Tester votre application.
6. Supprimer les attributs text et textColor des textView de votre
fichier XML et ajouter les à partir du code Java.
III. EditText
Permet de spécifier des zones de saisis dans vos activités.
Les principaux attributs de composants sont :
L’attribut Description
android:id Identifiant du contrôle. Il doit être unique dans le
l’activité.
android:text Le texte qui sera affiche dans le contrôle.
android:textcolor La couleur du texte du contrôle
android:textSize La taille du texte

ENSA-Tétouan /GSTR
android:textStyle Cet attribut peut contenir les valeurs suivantes :

0 : normal
1 : Bold
2 : Italic
Android :textalign Alignement du texte : center ; TextStart ; TextEnd
Android :hint Permet de saisir dans une zone de texte une explication.
Exemple :
Android :hintColor Permet de spécifier un couleur au texte hint

Android :InputType Permet de spécifier le type de texte :
- Number
- Text
- Phone
- …
Voici un exemple d’accès à un EditText en utilisant le code JAVA. Le EditText posséde le

code t1.
EditText t;
@Override
t = (EditText) findViewById(R.id.t1);
}
}
- Créer une application sous android studio.
- Créer l’IHM suivant :

ENSA-Tétouan /GSTR
IV. Button
Un button qui peut être pressé ou cliqué par l'utilisateur d'effectuer une action.
Pour récupérer le button dans le code java :
Button t;
@Override
t = (Button) findViewById(R.id.b1);
}
Nous avons 2 méthodes pour traiter l’événement click du button :

1ère méthode

Button t;
@Override
t.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
}
}
2ème méthode
public class MainActivity extends AppCompatActivity implements Button.OnClickListener{
Button t;
@Override
t.setOnClickListener(this);
@Override

ENSA-Tétouan /GSTR

switch (v.getId()){
case R.id.b1 : break;
}
}
}
Exercices d’application
Exercice 1
- Créer l’interface suivante :
- Ajouter un événement click au button qui permet d’afficher
dans une annonce Toast le mail saisi.
Exercice 2
- Créer l’interface suivante :
- Ajouter un événement au button, qui permet d’afficher
le message TVA le prix TTC dans un message Toast, sous la
forme PRIX TTC = 12.45 DH.
Le fichier MainActivity.xml
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context="com.example.formateur.ex01_tdi202.MainActivity">
<TextView
android:layout_height="wrap_content"
android:text="Prix Hors taxe : "/>
<EditText
android:id="@+id/pht"
android:inputType="numberDecimal"
android:background="#41ef3e"/>
<TextView
android:text="TVA : "/>
<EditText
android:id="@+id/tva"
android:background="#41ef3e"/>
<Button
android:layout_width="wrap_content"
android:text="Calculer le TTC"

ENSA-Tétouan /GSTR
android:id="@+id/b1"/>
</LinearLayout>
Le fichier MainActivity.java
EditText t1,t2 ;
Button b;
@Override
t1 = (EditText) findViewById(R.id.pht);
t2 = (EditText) findViewById(R.id.tva);
b = (Button) findViewById(R.id.b1);
b.setOnClickListener(new View.OnClickListener() {
@Override
double pht = Double.parseDouble(t1.getText().toString());
double tva = Double.parseDouble(t2.getText().toString());
double ttc = pht * (1+tva/100);
Toast.makeText(getApplication(), "PTTC : " + ttc, Toast.LENGTH_SHORT).show();
t1.setText("");
t2.setText("");
}
});
}
}
Exercice 3
- Créer une application sous android studio
- Créer l’interface suivant :
- Ajouter le code du button qui permet d’afficher
Connection OK si le login saisi est « toto » et le mot
de passe « toto ». Sinon le message « Connection KO »
sera affiché
Le fichier MainActivity.xml
<LinearLayout xmlns:android=http://schemas.android.com/apk/res/android
android:background="#000"
<EditText
android:id="@+id/login"
android:background="#ebf1ea"
android:layout_margin="10dp"
android:hint="Tapez votre login .."/>

ENSA-Tétouan /GSTR
<EditText
android:id="@+id/pass"
android:inputType="numberPassword"
android:hint="Tapez votre password .."/>
<Button
android:text="Connecter"
android:id="@+id/b1"
android:layout_margin="10dp"/>
</LinearLayout>
Le fichier MainActivity.java
EditText t1,t2 ;
Button b;
@Override
t1 = (EditText) findViewById(R.id.login);
t2 = (EditText) findViewById(R.id.pass);
@Override
if(t1.getText().toString().equals("toto") && t2.getText().toString().equals("toto"))
Toast.makeText(getApplication(), "Connexion Reussie", Toast.LENGTH_SHORT).show();
else
Toast.makeText(getApplication(), "Echec Conenxnion", Toast.LENGTH_SHORT).show();
}
});
}
}
Exercice 4
- En se basant sur l’ancien projet de l’exercice 3.
- Ajouter à votre projet la classe Utilisateur qui contient les éléments suivant :
o Les attributs : login et password
o Les accesseurs
- Dans la classe java de l’activité remplir une liste d’utilisateur.
- Modifier l’événement du button pour afficher Connection OK si le login et le mot de
passe existe dans la liste sinon le message « Connection KO » sera affiché.
Le fichier .xml

ENSA-Tétouan /GSTR
<EditText
android:id="@+id/login"
android:hint="Tapez votre login .."/>
<EditText
android:id="@+id/pass"
android:inputType="numberPassword"
android:hint="Tapez votre password .."/>
<Button
android:text="Connecter"
</LinearLayout>
Le fichier .java
EditText t1,t2 ;
Button b;
List<Utilisateur> users = new ArrayList<Utilisateur>();
@Override
t1 = (EditText) findViewById(R.id.login);
t2 = (EditText) findViewById(R.id.pass);
users.add(new Utilisateur("login1","123456"));
@Override
boolean trouve = false;
for(int i=0;i< users.size();i++)

if(users.get(i).getLogin().equals(t1.getText().toString()) &&
users.get(i).getPass().equals(t2.getText().toString())) {
trouve = true;
break;
}
if(trouve)

ENSA-Tétouan /GSTR
Toast.makeText(getApplication(), "Connexion Reussie", Toast.LENGTH_SHORT).show();

else
Toast.makeText(getApplication(), "Echec Conenxnion", Toast.LENGTH_SHORT).show();
}
});
}
}
Exercice 5

- Créer l’interface suivant :
-
Fichier .xml
<TextView
android:text="Nombre 1 :"
android:textColor="#faf2f2"/>
<EditText
android:id="@+id/zone1"
android:background="#9ff9a3"/>
<TextView
android:text="Nombre 2 :"
<EditText
<Button
android:text="Somme"
<Button
android:text="Soustraction"
<Button
android:text="Produit"

ENSA-Tétouan /GSTR
<Button
android:text="Division"
<TextView
android:text="Resultat :"
<EditText
</LinearLayout>
Fichier .java
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
EditText t1,t2,t3 ;
Button b1,b2,b3,b4;
List<Utilisateur> users = new ArrayList<Utilisateur>();
@Override
t1 = (EditText) findViewById(R.id.zone1);
b1 = (Button) findViewById(R.id.b1);
b1.setOnClickListener(this);
@Override
double a = Double.parseDouble(t1.getText().toString());
double b = Double.parseDouble(t2.getText().toString());
double c=0;
switch (v.getId()) {
case R.id.b1:
c = a + b;
break;
case R.id.b2:
c = a - b;
break;
case R.id.b3:
c = a * b;
break;
case R.id.b4:

ENSA-Tétouan /GSTR
if (b == 0)
Toast.makeText(getApplicationContext(), "Operation Invalid",
Toast.LENGTH_LONG).show();
else
c = a / b;
break;
}
t3.setText(String.valueOf(c));
}

ENSA-Tétouan /GSTR
Chapitre 2

l’Android
- Partie 2-

ENSA-Tétouan /GSTR
I. LinearLayout
Ce Layout se charge de mettre les vues sur une même ligne, selon une certaine orientation
(Verticale ou horizontale). L'attribut pour préciser cette orientation est android:orientation. On
peut lui donner deux valeurs :
 Vertical : pour que les composants soient placés de haut en bas (en colonne) ;
 Horizontal : pour que les composants soient placés de gauche à droite (en ligne).
Exemple 1 : Positionner les deux boutons d’une façon horizontale :

Le fichier activity_main.xml avec le résultat sont affichés ci-après :
<LinearLayout
android:orientation="horizontal">
<Button
android:id="@+id/btn01"
android:text="Bouton 01"/>
<Button
</LinearLayout>
Exemple 2 : Positionner les deux boutons d’une façon verticale :
<LinearLayout
android:orientation="vertical">
<Button
<Button
</LinearLayout>
Exemple 3 : Utilisation des layouts imbriqués :

ENSA-Tétouan /GSTR
tools:context="com.example.dell.myapplicationgravite.MainActivity">
<Button
android:text="Button01" />
<Button
<LinearLayout
<Button
<Button
</LinearLayout>
</LinearLayout>
1. Gravité des éléments

Dans un LinearLayout les éléments sont alignés de gauche à droite et de haut en bas. Donc la
question qui se pose est comment faire si l’on veut placer notre élément tout en bas ou à droite.
La réponse se trouve dans la gravité (android:gravity ou android :layout_gravity).
Les gravités les plus couramment utilisées sont left, center_horizontal, top, bottom, right, pour
respectivement aligner les éléments à gauche, au centre, en haut, en bas et à droite. On peut aussi
utiliser center_vertical pour centrer verticalement l’élément.
Exemple 1 : Mettre un bouton au centre de l’écran
tools:context="com.example.dell.myapplicationgravite.MainActivity"
android:gravity="center">
<Button
android:text="Button01"
android:id="@+id/button" />
</LinearLayout>

ENSA-Tétouan /GSTR
Exemple 2 :
android:gravity="center"
android:background="#8385f7">
<LinearLayout
android:layout_width="300dp"
android:layout_height="100dp"
android:background="#c1f5c1"
>
<EditText
android:hint="Saisir votre messsage ..."
android:background="#78ecd7"/>
<Button
android:text="Envoyer"
android:layout_gravity="center"
android:id="@+id/button"
android:background="#e90dd3"/>
</LinearLayout>
</LinearLayout>
2. Poids des éléments

Vous vous demandez sûrement ce que l’on veut dire par le poids d’un élément. Prenons un
exemple, imaginez que vous avez deux boutons en colonne et que vous voulez que chacun
occupe tout l’espace disponible.
 Si on leur affecte la même valeur au poids (android:layout_weight), l’espace libre sera
partagé équitablement entre les deux.
Exemple : Le fichier activity_main.xml avec le résultat sont affichés ci-après :
<Button
android:layout_weight="1"
/>
<Button

ENSA-Tétouan /GSTR
/>
</LinearLayout>
 Si l’on met une valeur 1 au premier et 2 au second, le deuxième prendra deux fois plus
d’espace libre que le premier (Par défaut la valeur du poids est de 0).
Exemple : Le fichier activity_main.xml avec le résultat sont affichés ci-après :

<Button
/>
<Button
/>
</LinearLayout>
II. Exercices d’application

Exercice 1 :
Créer les interfaces suivantes :
1.

tools:context="com.example.formateur.exo05_tdi201.MainActivity"
<LinearLayout
android:orientation="horizontal"
android:layout_marginBottom="10dp">
<TextView

ENSA-Tétouan /GSTR
android:text="Nombre 1 :"/>
<EditText
android:layout_marginRight="15dp"/>
</LinearLayout>

<LinearLayout
<TextView
android:text="Nombre 1 :"/>
<EditText
</LinearLayout>
<LinearLayout
<Button
android:text="+"
android:layout_weight="1"/>
<Button
android:text="-"
<Button
android:text="*"
<Button
android:text="/"
/>
</LinearLayout>
<LinearLayout
android:layout_height="wrap_content">
<TextView
android:text="Resultat :"/>
<EditText

ENSA-Tétouan /GSTR
</LinearLayout>
</LinearLayout>
2.

tools:context="com.example.formateur.exo05_tdi201.MainActivity"


<LinearLayout
android:layout_weight="1">
<TextView
android:text="Nom : "/>
<EditText
android:background="#10e71e"/>
</LinearLayout>


<LinearLayout
<TextView
android:text="Prénom : "/>
<EditText
</LinearLayout>


<LinearLayout
<RadioButton
android:text="Homme"/>

ENSA-Tétouan /GSTR
<RadioButton
android:text="Femme"/>
</LinearLayout>


<LinearLayout
<TextView
android:text="Date Naissance : "/>
<EditText
android:inputType="date"
</LinearLayout>
<TextView
android:text="Liste des diplomes : "


<LinearLayout
<CheckBox
android:text="Bac + 2"/>
<CheckBox
android:text="License"/>
</LinearLayout>


<LinearLayout
<CheckBox
android:text="Master"/>
<CheckBox
android:text="Doctorat"/>
</LinearLayout>


<LinearLayout

ENSA-Tétouan /GSTR
<Button
android:text="Save"
<Button
android:text="RAZ"
</LinearLayout>
</LinearLayout>
3.
Exercice 2 :
Développer une calculatrice :

ENSA-Tétouan /GSTR
Solution de l’exercice 2 :
Le ficher .java

EditText ed;
Button
btnC,btnMod,btnDiv,btn1,btn2,btn3,btn4,btn5,btn6,btn7,btn8,btn9,btnPlus,btnMoins,btnProd,btnVi
r, btn0,btnPM, btnEga;
char op;
double nombre1;
@Override
ed=(EditText) findViewById(R.id.zone);
btn0 = (Button) findViewById(R.id.btn0);

btn0.setOnClickListener(this);
btnC = (Button) findViewById(R.id.btnC);
btnC.setOnClickListener(this);
btnPlus = (Button) findViewById(R.id.btnPlus);
btnPlus.setOnClickListener(this);
btnMod = (Button) findViewById(R.id.btnMod);
btnMod.setOnClickListener(this);
btnDiv = (Button) findViewById(R.id.btnDiv);
btnDiv.setOnClickListener(this);
btnMoins = (Button) findViewById(R.id.btnMoins);
btnMoins.setOnClickListener(this);
btnProd = (Button) findViewById(R.id.btnProd);
btnProd.setOnClickListener(this);
btnEga = (Button) findViewById(R.id.btnEgale);
btnEga.setOnClickListener(this);
btnPM = (Button) findViewById(R.id.btnPM);
btnPM.setOnClickListener(this);
btnVir = (Button) findViewById(R.id.btnVir);
btnVir.setOnClickListener(this);
}
@Override

ENSA-Tétouan /GSTR

Button b = (Button)v;
switch (v.getId()){
case R.id.btn1 :
case R.id.btn2 :
case R.id.btn3 :
case R.id.btn4 :
case R.id.btn5 :
case R.id.btn6 :
case R.id.btn7 :
case R.id.btn8 :
case R.id.btn9 :
if(!ed.getText().equals("0"))
ed.setText(ed.getText().toString() + b.getText().toString());
else
ed.setText(b.getText().toString());
break;
case R.id.btn0 :
if(!ed.getText().equals(""))
ed.setText(ed.getText().toString() + b.getText().toString());
case R.id.btnPlus :
op = '+';
ed.setText("");
break;
case R.id.btnMoins :
op = '-';
nombre1 = Double.parseDouble(ed.getText().toString());
ed.setText("");break;
case R.id.btnProd :
op = '*';
ed.setText("");
break;
case R.id.btnMod :
op = '%' ;
case R.id.btnDiv :
op = '/' ;
case R.id.btnEgale : {
double nombre2 = Double.parseDouble(ed.getText().toString());
switch (op) {
case '+':
ed.setText(String.valueOf(nombre1+nombre2));
break;
case '-':
ed.setText(String.valueOf(nombre1-nombre2));
break;
case '%':
ed.setText(String.valueOf(nombre1%nombre2));
break;
case '/':
ed.setText(String.valueOf(nombre1/nombre2));
break;
case '*':
ed.setText(String.valueOf(nombre1*nombre2));
break;
}

ENSA-Tétouan /GSTR
}
break;
}
}
}
Le fichier .xml
android:background="#b0fbd5"
tools:context="com.example.formateur.calculatriceapp.MainActivity">
<EditText
android:textSize="50dp"
android:hint="0"
android:gravity="right"
android:background="#faf7f7"
android:id="@+id/zone"/>
<LinearLayout
<Button
android:text="C"
android:id="@+id/btnC"
android:background="#4f13f5"
android:textColor="#fbf8f8"/>
<Button
android:text="%"
android:id="@+id/btnMod"
<Button
android:text="/"
android:id="@+id/btnDiv"
</LinearLayout>
<LinearLayout
<Button

ENSA-Tétouan /GSTR
android:text="1"
/>
<Button
android:text="2"
<Button
android:text="3"
<Button
android:text="+"
android:id="@+id/btnPlus"
</LinearLayout>
<LinearLayout
<Button
android:text="4"
/>
<Button
android:text="5"
<Button
android:text="6"
<Button
android:text="-"

ENSA-Tétouan /GSTR
android:id="@+id/btnMoins"
</LinearLayout>
<LinearLayout
<Button
android:text="7"
/>
<Button
android:text="8"
<Button
android:text="9"
<Button
android:text="*"
android:id="@+id/btnProd"
</LinearLayout>
<LinearLayout
<Button
android:text=","
android:id="@+id/btnVir"
/>
<Button
android:text="0"
<Button

ENSA-Tétouan /GSTR
android:text="+/-"
android:id="@+id/btnPM"
<Button
android:text="="
android:id="@+id/btnEgale"
</LinearLayout>
</LinearLayout>

ENSA-Tétouan /GSTR
Chapitre 2

l’Android
- Partie 3-

ENSA-Tétouan /GSTR
I. RadioButton
On regroupe les RadioButton dans un RadioGroup.
Exemple :
<RadioGroup
android:layout_width="fill_parent"
<RadioButton android:id="@+id/radio1"
android:checked="true"
android:text="Homme" />
<RadioButton
android:id="@+id/radio2"
android:text="Femme"
</RadioGroup>
Le résultat de ce code est :
Pour faire l’association entre java et l’objet :
rd1 = (RadioButton) findViewById(R.id.radio1);

rd2 = (RadioButton) findViewById(R.id.radio2);
Pour cocher ou décocher le radioButton :
rd1.setChecked(true);
rd2.setChecked(false);
Pour tester si un radioButton est coché ou non :
if(rd1.isChecked())
Toast.makeText(this,"radio 1 coché",Toast.LENGTH_LONG).show();
if(rd2.isChecked())
Toast.makeText(this,"radio 2 coché",Toast.LENGTH_LONG).show();
Pour Créer un événement si le radioButton est coché :
rd1.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

ENSA-Tétouan /GSTR
Toast.makeText(getApplicationContext(),"radio 1 coché",Toast.LENGTH_LONG).show();
}
});
II. ImageView
Cette vue permet d’afficher des images.
Exemple :
<ImageView
android:layout_height="495dp"
android:src="@drawable/i1"
android:id="@+id/img"/>
Pour modifier l’image à l’aide du code :
ImageView img = (ImageView) findViewById(R.id.img);

img.setImageResource(R.drawable.i3);
III. Exercice d’application

Exercice 1 :
1. Créer un nouveau projet sous android studio.
2. Créer l’activité suivante :

ENSA-Tétouan /GSTR
3. A l’aide de l’événement OnCheckedChanged, ajouter des événements aux radios

buttons des couleurs. Pour permettre de changer la couleur de texte dans le texteView
qui se trouve à la fin de l’activité.
4. A l’aide de l’événement OnCheckedChanged, ajouter des événements aux radios
buttons sur les tailles. Pour permettre de changer la taille de texte dans le texteView qui
se trouve à la fin de l’activité.
5. A l’aide de l’événement OnCheckedChanged, ajouter des événements aux CheckBox
buttons des styles. Pour permettre de changer le style du texte dans le texteView qui se
trouve à la fin de l’activité. (Utiliser la fonction setTypeFace).
Exercice 2 :
1. Créer nouveau projet sous android studio.

2. Ajouter les images dans le dossier drawable de votre projet.
3. Créer l’activité suivantes

ENSA-Tétouan /GSTR
4. Ajouter l’événement OnCheckBoxChanged pour changer l’image à chaque clique.

5. Ajouter l’événement OnTouch pour changer l’image à l’image suivante à chaque
clique sur l’image.
Exercice 3 :
1. Créer un nouveau projet sous android studio

3. Ajouter les images dans le dossier drawable de votre projet.
4. Créer la classe Stagiaire qui contient les attributs suivants :
5. Nom (String)
6. Prénom (String)
7. Sexe (String)
8. Image (int)
9. Créer une liste dans la classe java de l’activité.
10. Remplir cette liste avec 4 stagiaire.
11. Ecrire le code de chaque button :
12. << : afficher le premier Stagiaire
13. < : afficher le précédent Stagiaire
14. >> : Afficher le dernier stagiaire
15. > : afficher le stagiaire suivant.
16. Créer un événement OnTouch sur l’image pour passer naviguer sur les stagiaires
suivant et précédent.
Solution :
Le fichier xml

tools:context="com.example.formateur.exo3_radio.MainActivity">
<LinearLayout
<TextView
<EditText
android:id="@+id/nom"/>
</LinearLayout>
<LinearLayout

ENSA-Tétouan /GSTR
<TextView
<EditText
android:id="@+id/prenom"/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Sexe : "/>
<RadioGroup
<RadioButton
android:text="Homme"
android:id="@+id/r1"/>
<RadioButton
android:text="Homme"
android:id="@+id/r2"/>
</RadioGroup>
</LinearLayout>
<ImageView
<LinearLayout
<Button
android:text="<<"
<Button
android:text="<"
<Button
android:text=">"

ENSA-Tétouan /GSTR
<Button
android:text=">>"
</LinearLayout>
</LinearLayout>
Le fichier java.
List<Stagiaire> st = new ArrayList<>();

EditText nom, prenom;
RadioButton r1,r2;
ImageView img;
Button b1,b2,b3,b4;
float x1,x2;
int pos=0;
@Override
st.add(new Stagiaire("TAN","THOMAS","HOMME",R.drawable.i1));
st.add(new Stagiaire("BABI","ISA","FEMME",R.drawable.i2));
st.add(new Stagiaire("HAKAM","MARINE","FEMME",R.drawable.i3));
st.add(new Stagiaire("DEPEL","NICOLAS","HOMME",R.drawable.i4));
nom = (EditText) findViewById(R.id.nom);

prenom = (EditText) findViewById(R.id.prenom);
r1 = (RadioButton) findViewById(R.id.r1);
r2 = (RadioButton) findViewById(R.id.r2);
img = (ImageView) findViewById(R.id.img);
pos=0;
remplissage();
}
public void remplissage(){
nom.setText(st.get(pos).getNom());
prenom.setText(st.get(pos).getPrenom());

ENSA-Tétouan /GSTR
if(st.get(pos).getSexe().equals("HOMME"))
r1.setChecked(true);
if(st.get(pos).getSexe().equals("FEMME"))
r2.setChecked(true);
img.setImageResource(st.get(pos).getImage());
img.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
if(event.getAction()==MotionEvent.ACTION_DOWN)
x1=event.getX();
if(event.getAction()==MotionEvent.ACTION_UP) {
x2 = event.getX();
if (x1 > x2)

pos++;
else
pos--;
if (pos == st.size())
pos = 0;
if (pos == -1)
pos = st.size()-1;
remplissage();
}
return true;
}
});
}
@Override
switch (v.getId()){
case R.id.b1 :
pos=0;
break;
case R.id.b2 :
pos--;
if(pos==-1)
pos=st.size()-1;
break;
case R.id.b3 :
pos++;
if(pos==st.size())
pos=0;
break;
case R.id.b4 :
pos = st.size()-1;
break;
}
remplissage();
}
}

ENSA-Tétouan /GSTR
Chapitre 3
Les INTENTS

ENSA-Tétouan /GSTR
I. Définition
Les Intents sont des messages qui permettent aux composants d'une application de demander
des fonctionnalités à d’autres composants Android.
Les Intents vous permettent d'interagir avec vos propres composants ou des composants d'autres
applications. Par exemple, une activité peut démarrer une autre activité pour prendre une photo.
II. Ouverture d’une autre activité

1. Sans transmission des données
Voici un exemple d’ouverture d’une activité sans transmission des données :
Fichier activity_main.xml avec le résultat :

xmlns:app="http://schemas.android.com/apk/res-auto"
tools:context="com.example.dell.ouvertureactivities.MainActivity">
<Button
android:text="Ouvrir l'activité 2"
android:id="@+id/b"/>
</LinearLayout>
Dans le code Java du button « Ouvrir l’activité 2 » :
Button b;
@Override
b=(Button) findViewById(R.id.b);
@Override
Intent i = new Intent(getApplicationContext(),Main2Activity.class);

startActivity(i);
}
});

ENSA-Tétouan /GSTR
}
}
2. Avec transmission des données
Voici un exemple d’ouverture d’activité avec transmission des données :
tools:context="com.example.dell.ouvertureactivities.MainActivity">
<LinearLayout
<TextView
android:text="Valeur 1 : "
android:textSize="20dp"/>
<EditText
android:id="@+id/e1"
/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Valeur 2 : "
android:textSize="20dp"/>
<EditText
android:id="@+id/e2"
/>
</LinearLayout>
<Button
android:text="Ouvrir l'activité 2"
android:id="@+id/b"/>
</LinearLayout>
Dans le fichier Java:
Button b;

ENSA-Tétouan /GSTR
EditText e1,e2;
@Override
b=(Button) findViewById(R.id.b);
e1=(EditText) findViewById(R.id.e1);
e2=(EditText) findViewById(R.id.e2);
@Override
Intent i = new Intent(getApplicationContext(),Main2Activity.class);
i.putExtra("val1",e1.getText());
i.putExtra("val2",e2.getText());
startActivity(i);
}
});
}
}
Dans l’activité 2, on va afficher les paramètres passés dans un textView :
public class Main2Activity extends AppCompatActivity {
TextView tv;
@Override
setContentView(R.layout.activity_main2);
tv = (TextView) findViewById(R.id.tv);
Bundle extras = getIntent().getExtras();
String val1 = extras.get("val1").toString();

String val2 = extras.get("val2").toString();
tv.setText("Bienvenue : "+ val1 + " " + val2);

}
}
1. Créer un nouveau projet Android Studio

2. Ajouter la classe Utilisateur :
a. Les attributs :
login, passwd, nom, prenom, dateNaissance, Image(Int)
b. Ajouter à la classe les propriétés et les constructeurs
4. Ajouter à la classe de cette activité, une liste des utilisateurs.
5. Ecrire le code du button « Se connecter » :
a. Si le login et le passwd saisis par l’utilisateur
existe dans la liste. Afficher dans une autre activité
tous les informations de cet utilisateur.

ENSA-Tétouan /GSTR
b. Sinon afficher un message Toast : « Vérifier votre login et mot de passe ».
III. Accéder au composant du mobile

1. Appel téléphonique
Pour passer un appel téléphonique à partir d’une application Android, Il faut ajout la permission
dans le fichier manifest.xml.
<uses-permission android:name="android.permission.CALL_PHONE" />
Dans le fichier XML :

tools:context="com.example.dell.appeltelphonique.MainActivity">
<EditText
android:id="@+id/t1"
android:hint="Votre N° de tél ...."
android:inputType="phone"/>
<Button
android:text="Appeler"
</LinearLayout>
Dans le fichier JAVA :
EditText e;
Button b;
@Override
e = (EditText) findViewById(R.id.t1);
@Override
public void onClick(View view) {
String tel = e.getText().toString();// Votre numéro de téléphone
Intent callIntent = new Intent(Intent.ACTION_CALL);
callIntent.setData(Uri.parse("tel:" + tel));
startActivity(callIntent);
}

ENSA-Tétouan /GSTR
});
}
}
2. Camera
Voici un exemple d’utilisation de la caméra dans une application android.
1. Ajouter la permission dans le fichier manifest.xml

<uses-permission android:name="android.permission.CAMERA"/>
2. Dans le fichier XML

tools:context="com.example.dell.myapplication.MainActivity">
<Button
android:text="Prendre photo"
android:layout_gravity="center"
/>
<ImageView
</LinearLayout>
Dans le fichier JAVA :
ImageView img;
Button b;
@Override
img = (ImageView) findViewById(R.id.img);

@Override
Intent i = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
startActivityForResult(i,0);
}
});

ENSA-Tétouan /GSTR
}
@Override
protected void onActivityReult(int requestCode, int resultCode, Intent data){
Bitmap bit = (Bitmap) data.getExtras().get("data");
img.setImageBitmap(bit);
}
}

ENSA-Tétouan /GSTR
Chapitre 4
Les LISTVIEW

ENSA-Tétouan /GSTR
I. Introduction
Sous Android, le composant principal pour afficher et gérer une liste de données est le
composant ListView.
Par défaut ce composant affiche une liste de chaines de caractères. Selon les besoins, il peut être
nécessaire d'afficher plus d'informations sur chaque ligne de la liste, ou même de venir effectuer
des opérations particulières suite à des actions sur les lignes.
II. Adapters et ListView

L’intermédiaire entre la liste et la vue est géré par un adaptateur, objet qui sait comment attacher
un item dans le ListView.
1. ArrayAdapter et ListView
Il permet d’afficher les données d’un ArrayList, mais il est limité à une seule chaîne par item.

ENSA-Tétouan /GSTR
Exemple :
Le fichier XML qui contient la listView:

tools:context="com.example.dell.androidlist.MainActivity">
<ListView
android:id="@+id/liste">
</ListView>
</LinearLayout>
Le fichier XML qui va contenir le format de chaque item.
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/t1"
/>
</LinearLayout>
Le fichier JAVA :
ListView liste;
String[] chaines;
@Override
liste = (ListView) findViewById(R.id.liste);
final String[] chaines = {"Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi"};
ArrayAdapter <String> ad =new ArrayAdapter<String>(this,R.layout.ligne_item,R.id.t1,chaines);
liste.setAdapter(ad);
liste.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
Toast.makeText(getApplicationContext(), chaines[i], Toast.LENGTH_SHORT).show();
}
});
}
}

ENSA-Tétouan /GSTR
2. Exercice d’application
1. Créer une nouvelle application sous Android studio.
2. Créer une activité qui permet d’afficher la liste des filières
de l’ENSA.
3. Ajouter un événement qui va permettre à chaque clique sur
une filière d’afficher plus d’informations sur cette filière :
a. Description
b. Nombre d’heures
c. Type de formation
d. Formateur
III. CustomAdapter et ListView

1. Introduction
L’adaptateur répond à la question que pose le ListView : « que dois-je afficher à tel endroit dans
la liste ?». Il va chercher les données et instancie le layout d’item avec les valeurs.
La génération de vues pour afficher les items repose sur un mécanisme appelé LayoutInflater
qui fabrique des vues Android à partir d’un layout XML :
Exemple :
Pour expliquer cette partie, on va le faire à l’aide d’un exemple :

1. On commence par créer la classe Pays
public class Pays {
private int image;

private String nom;
public Pays(int image, String nom) {

this.image = image;
this.nom = nom;

ENSA-Tétouan /GSTR
}
public int getImage() {
return image;
}
public void setImage(int image) {
this.image = image;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
}
2. Créer la classe Myadapters qui hérite de la classe ArrayAdapter.
public class MyAdapter extends ArrayAdapter<Pays> {
ArrayList<Pays> pays;
Context c;
public MyAdapter(Context context, ArrayList<Pays> pays) {

super(context, R.layout.item_row);
this.pays = pays;
this.c = context;
}
@Override
public int getCount() {
return pays.size();
}
@NonNull
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder v = new ViewHolder();
if(convertView==null) {
convertView = LayoutInflater.from(c).inflate(R.layout.item_row, parent, false);
v.image = (ImageView) convertView.findViewById(R.id.img);
v.texte = (TextView) convertView.findViewById(R.id.NameCountry);
}
else
{
v =(ViewHolder) convertView.getTag();
}
v.image.setImageResource(pays.get(position).getImage());
v.texte.setText(pays.get(position).getNom());
convertView.setTag(v);
return convertView;
}
static class ViewHolder

ENSA-Tétouan /GSTR
{
ImageView image;
TextView texte;
}
}
3. Dans le main_activity.java :
ListView listv;
ArrayList<Pays> pays = new ArrayList<>();
@Override
listv = (ListView) findViewById(R.id.listv);
pays.add(new Pays(R.drawable.algeria64,"Algerie"));
pays.add(new Pays(R.drawable.argentina64,"Argentina"));
pays.add(new Pays(R.drawable.brazil64,"Brazil"));
pays.add(new Pays(R.drawable.ghana64,"Ghana"));
pays.add(new Pays(R.drawable.spain64,"Spain"));
MyAdapter p = new MyAdapter(MainActivity.this,pays);
listv.setAdapter(p);
listv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Intent intent = new Intent(MainActivity.this,DetailActivity.class);
intent.putExtra("countryname",pays.get(position).getNom());
intent.putExtra("countryflag",pays.get(position).getImage());
startActivity(intent);
}
});
}
}
4. Le fichier main_activity.XML :
tools:context="com.example.dell.exemple_flagcountries.MainActivity">
<android.support.v7.widget.Toolbar
android:background="?attr/colorPrimary"
android:theme="?attr/actionBarTheme"
android:minHeight="?attr/actionBarSize"
android:layout_alignParentTop="true"

ENSA-Tétouan /GSTR
android:layout_alignParentEnd="true"
android:id="@+id/toolbar"
app:popupTheme="@style/ThemeOverlay.AppCompat.Dark"
app:theme="@style/Base.ThemeOverlay.AppCompat.Light"
app:title="List of countries" />
<ListView
android:id="@+id/listv"
>
</ListView>
</LinearLayout>
5. Le fichier item_row.xml :
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
>
<ImageView
android:padding="5dp"
android:src="@drawable/chile64"
android:id="@+id/img"
/>
<TextView
android:text="Name of the country"
android:id="@+id/NameCountry"/>
</LinearLayout>
</LinearLayout>
1. Créer une application sous android studio.
2. Ajouter la classe contact qui contient les informations suivantes :
a. Image (int)
b. Nom
c. Prénom
d. Email
e. Fax
f. Tel fixe
g. Tel portable.

ENSA-Tétouan /GSTR
3. Créer une activité qui va permettre d’afficher une liste des contacts. Les informations à
afficher dans chaque item sont :
a. Image
b. Nom
c. Prénom
La clique sur un item permet d’ouvrir une autre activité pour afficher tous les informations.

ENSA-Tétouan /GSTR
Chapitre 5
SQLLITE SOUS ANDROID

ENSA-Tétouan /GSTR
Table des matières

1. Présentation de SQLite et Android ........................................................................ 62
2. SQLite sous android ............................................................................................... 62
3. Création et mise à jour d’une base de données ...................................................... 62
4. Insertion des données ......................................................................................... 64
5. Afficher les données ........................................................................................... 66
6. Mise à jour des données ..................................................................................... 67
7. Suppression des données .................................................................................... 68

ENSA-Tétouan /GSTR
1. Presentation de SQLite et Android
SQLite est un système de gestion de base des données.
SQLLite est le SGBD le plus distribué au monde, grâce à son utilisation dans de nombreux
logiciels grand public comme Firefox, Skype et dans certains produits d'Apple, d'Adobe et de
McAfee et dans les bibliothèques standards de nombreux langages comme PHP ou Python.
Une base de données sous Android nécessite peu de mémoire lors de l'exécution (env. 250 ko),
ce qui en fait un bon candidat pour être intégré dans d'autres environnements d'exécution.
2. SQLite sous android
SQLite est intégrée dans chaque appareil Android. L'utilisation d'une base de données SQLite
sous Android ne nécessite pas de configuration ou d'administration de la base de données.
Vous devez uniquement définir les instructions SQL pour créer et mettre à jour la base de
données. Ensuite, celleci est gérée automatiquement pour vous, par la plate-forme Android.
Si votre application crée une base de données, celle-ci est par défaut enregistrée dans le
répertoire
DATA /data/ APP_NAME/databases/FILENAME.
3. Création et mise à jour d’une base de données
Pour créer et mettre à jour une base de données dans votre application Android, vous créez une
classe qui hérite de SQLiteOpenHelper. Dans le constructeur de votre sous-classe, vous appelez
la méthode super( ) de SQLiteOpenHelper, en précisant le nom de la base de données et sa
version actuelle.
Dans cette classe, vous devez redéfinir les méthodes suivantes pour créer et mettre à jour votre
base de données :
 onCreate() : est appelée pour accéder à une base de données qui n'est pas encore créée.
 onUpgrade() : Cette méthode vous permet de mettre à jour un schéma de base de
données existant ou de supprimer la base de données existante et la recréer par la
méthode onCreate().
Exemple :
public class MyDataBase extends SQLiteOpenHelper {
public static final String DATABASE_NAME = "Student.db";

public static final String TABLE_NAME = "Student_table";
public static final String COL_1 = "ID";

public static final String COL_2 = "NOM";
public static final String COL_3 = "PRENOM";
public static final String COL_4 = "NOTE";
public MyDataBase(Context context) {

super(context, DATABASE_NAME, null, 1);

ENSA-Tétouan /GSTR
@Override
public void onCreate(SQLiteDatabase sqLiteDatabase) {
sqLiteDatabase.execSQL("CREATE TABLE " + TABLE_NAME + " ("+COL_1 + " INTEGER
PRIMARY KEY AUTOINCREMENT, "+ COL_2 + " TEXT, "+COL_3 + " TEXT, "+COL_4+"
INTEGER)");
}
@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {
sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(sqLiteDatabase);
}
}
Dans le fichier MainActivity.java :
MyDataBase db;
@Override
// La ligne qui créer la base de données

db = new MyDataBase(this);
}
}
Pour chaque table, il faut créer une classe qui contient les mêmes champs que la table :
public class Student {

private int id;
private String nom;
private String prenom;
private int note;
public Student(){
}
public Student(int id, String nom, String prenom, int note) {
this.id = id;
this.nom = nom;
this.prenom = prenom;
this.note = note;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNom() {

return nom;

ENSA-Tétouan /GSTR
}
public void setNom(String nom) {
this.nom = nom;
}
public String getPrenom() {
return prenom;
}
public void setPrenom(String prenom) {
this.prenom = prenom;
}
public int getNote() {
return note;
}
public void setNote(int note) {
this.note = note;
}
}
4. Insertion des données

Voici un exemple d’insertion dans une base de données SQLite :
Le fichier XML de cette activité est :

tools:context="mobile.tetouan.ofppt.ismo.exemple1sqlite.MainActivity">
<LinearLayout
<TextView
<EditText
android:id="@+id/t_nom"/>
</LinearLayout>
<LinearLayout
<TextView
<EditText

ENSA-Tétouan /GSTR
android:id="@+id/t_prenom"/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Note : "/>
<EditText
android:id="@+id/t_note"/>
</LinearLayout>
<LinearLayout
<Button
android:text="Save"
android:id="@+id/btn_save"/>
</LinearLayout>
</LinearLayout>
Le fichier mainActivity.java est :
MyDataBase db;
EditText t1,t2,t3;
Button b1;
@Override
t1 = (EditText) findViewById(R.id.t_nom);
t2 = (EditText) findViewById(R.id.t_prenom);
t3 = (EditText) findViewById(R.id.t_note);
b1 = (Button) findViewById(R.id.btn_save);

ENSA-Tétouan /GSTR
b1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Student s = new Student();
s.setNom(t1.getText().toString());
s.setPrenom(t2.getText().toString());
s.setNote(Integer.parseInt(t3.getText().toString()));
long r=MyDataBase.insertStudent(db.getWritableDatabase(),s);
if(r!=-1){
Toast.makeText(getApplicationContext(),"Insertion
Reussie",Toast.LENGTH_LONG).show();
}else{
Toast.makeText(getApplicationContext(),"Insertion
Echoue",Toast.LENGTH_LONG).show();
}
}
});
}
}
Il faut ajouter la méthode insertStudent dans la classe MyDataBase comme suit :
public static long insertStudent(SQLiteDatabase db, Student s){

ContentValues insertValues = new ContentValues();
insertValues.put(MyDataBase.COL_2,s.getNom());
insertValues.put(MyDataBase.COL_3,s.getPrenom());
insertValues.put(MyDataBase.COL_4,s.getNote());
long result = db.insert(MyDataBase.TABLE_NAME,null,insertValues);
db.close();
return result;
}
5. Afficher les données

Nous allons afficher les Etudiants enregistrés dans la base de données dans une ListView.
Le fichier MainActivity.xml :

tools:context="mobile.tetouan.ofppt.ismo.exemple1sqlite.MainActivity">
<ListView
android:id="@+id/list">
</ListView>
</LinearLayout>
Le fichier MainActivity.java :

ENSA-Tétouan /GSTR
MyDataBase db;
ListView lst;
@Override
ListView ls = (ListView) findViewById(R.id.list);
ArrayList<Student> sts = MyDataBase.getAllStudents(db.getReadableDatabase());
String[] noms = new String[sts.size()];
int i=0;
for(Student s:sts) {
noms[i] = s.getNom();
i++;
}
ArrayAdapter ad = new ArrayAdapter(this,R.layout.item_row,R.id.tt,noms);

ls.setAdapter(ad);
}
}
Il faut ajouter la méthode getAllStudents dans la classe MyDataBase comme suit :
public static ArrayList<Student> getAllStudents(SQLiteDatabase db) {
ArrayList<Student> stds = new ArrayList<>();
Cursor cur = db.rawQuery("SELECT * FROM "+MyDataBase.TABLE_NAME,null);
while(cur.moveToNext()){
Student s = new Student();
s.setId(cur.getInt(0));
s.setNom(cur.getString(1));
s.setPrenom(cur.getString(2));
s.setNote(cur.getInt(3));
stds.add(s);
}
return stds;
}
6. Mise à jour des données

Pour mettre à jour les informations d’un étudiant, on ajoute la méthode suivante dans la classe
MyDataBase :

ENSA-Tétouan /GSTR
public static long updateStudent(SQLiteDatabase db,Student s){

ContentValues insertValues = new ContentValues();
insertValues.put(MyDataBase.COL_2,s.getNom());
insertValues.put(MyDataBase.COL_3,s.getPrenom());
insertValues.put(MyDataBase.COL_4,s.getNote());
long result = db.update(MyDataBase.TABLE_NAME,insertValues,"ID = "+s.getId(),null);
db.close();
return result;
}
7. Suppression des données

Pour supprimer un étudiant on ajouter à la classe MyDataBase la méthode deleteStudent :
public static long deleteStudent(SQLiteDatabase db,int id){

long result = db.delete(MyDataBase.TABLE_NAME,"id = "+id,null);
db.close();
return result;
}

ENSA-Tétouan /GSTR
Chapitre 6
LES RESSOURCES

ENSA-Tétouan /GSTR
Table des matières
I. Les ressources ........................................................................................................ 71
1. Introduction ........................................................................................................ 71
2. Gestion des chaines de caractères ...................................................................... 71
3. Les couleurs ........................................................................................................ 71
4. Les styles ............................................................................................................ 72
II. Les shapes Drawable.............................................................................................. 72
III. Les states drawables ............................................................................................... 73

ENSA-Tétouan /GSTR
I. Les ressources
1. Introduction
Nous allons désormais parler des ressources. Les ressources sont des fichiers qui contiennent des
informations qui ne sont :
 Pas en Java (ce n'est donc pas du code).
 Pas dynamique (le contenu d'une ressource restera inchangé entre le début de l'exécution
de votre application et la fin de l'exécution).
L'avantage des ressources, c'est qu'elles nous permettent de nous adapter facilement à toutes ces
situations différentes.
2. Gestion des chaines de caractères

Les chaines de caractères sont déclarées dans le fichier strings.xml dans le dossier values.
Exemple de déclaration des chaines de caractères :
<resources>
<string name="app_name">Gestion des contacts</string>
<string name="exemple1">Chaine de caractéres</string>
<string-array name="exemple2">
<item>TDI</item>
<item>TRI</item>
<item>INFO</item>
<item>TMSIR</item>
<item>CRJJ</item>
<item>BCMOS</item>
</string-array>
</resources>
L’utilisation des chaines simples :

 Dans le code java : getString(R.string.exemple1)
 Dans le fichier layout.xml :
<TextView
android:id="@+id/id1"
android:text="@string/exemple1"
/>
L’utilisation des tableaux de chaines :
String[] s = getResources().getStringArray(R.array.exemple1);
3. Les couleurs
Les couleurs sont enregistrés dans le fichier colors.xml.

ENSA-Tétouan /GSTR
Exemple de déclaration :
<resources>
<color name="opaque_red">#f00</color>
<color name="translucent_red">#80ff0000</color>
</resources>
L’utilisation dans le code java : R.color.opaque_red

Dans le fichier layout.xml :
<TextView
android:layout_width="fill_parent"
android:textColor="@color/translucent_red"
android:text="Hello"/>
4. Les styles
Un style est une collection de propriétés qui spécifient le design d'une vue, d'un élément ou d'une
application. Il peut spécifier différentes propriétés :
 Margin ;
 Hauteur ;
 Largeur ;
 Couleur du texte ;
 Taille du texte ;
 etc.
Un style se définit dans un fichier ressource XML séparé du fichier XML de votre vue. Ce
fichier se nomme en général styles.xml et se situe dans le dossier values.
Exemple de déclaration d’un style :
<style name="style1">
<item name="android:layout_width">wrap_content</item>
<item name="android:layout_height">match_parent</item>
<item name="android:textSize">30dp</item>
<item name="android:textColor">@color/opaque_red</item>
</style>
Pour Associer ce style à un élément :
<TextView
style="@style/style1"
android:text="@string/hello" />
II. Les shapes Drawable

Les drawables shape (forme) vous permettent de définir des formes primitives simples en
spécifiant leurs dimensions, fond et conteur à l’aide de la balise <shape>
Exemple de déclaration :

ENSA-Tétouan /GSTR
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<corners android:radius="8dp" />

<solid android:color="#e64545"/>
<stroke android:width="2dp"/>
</shape>
Exemple d’utilisation :
<Button
android:id="@+id/aj_b1"
android:text="@string/aj_remove"
android:background="@drawable/ex1"/>
III. Les states drawables

Les « state drawables » permettent de définir des états. Pour chaque état, l'on peut assigner à la
vue un drawable différent. Par exemple, le code suivant définit les différents drawables pour un
bouton en fonction de son état :
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/ex2" android:state_pressed="true"/>

<item android:drawable="@drawable/ex1" android:state_enabled="true"/>
</selector>

Plycopie Java Mobile Final

Transféré par

Informations du document

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

Plycopie Java Mobile Final

Transféré par

Droits d'auteur :

Formats disponibles

Module : Systèmes embarqués 2 et

Elément : Java mobile

Pr. Fouad AYTOUNA

Année Universitaire 2019-2020

Pr. Fouad AYTOUNA Java Mobile 1

Pr. Fouad AYTOUNA Java Mobile 2

Table des matières

I. Développement mobile ............................................................................................ 4

II. Les principaux OS mobiles .................................................................................. 4

III. Présentation Android ............................................................................................ 4

IV. Les versions de l’Android .................................................................................... 5

V. Google play .......................................................................................................... 5

VI. Architecture Android ............................................................................................ 6

VII. Dalvik et ART ...................................................................................................... 6

VIII. SDK Android........................................................................................................ 6

IX. Compilation et déploiement ................................................................................. 6

X. Android Studio ..................................................................................................... 7

AVD: le gestionnaire d'appareils .................................................................................... 7

XI. Structure projet Android ....................................................................................... 7

Les ressources ................................................................................................................. 7

Le fichier manifest.xml .................................................................................................. 7

Les packages ................................................................................................................... 8

Pr. Fouad AYTOUNA Java Mobile 3

Pr. Fouad AYTOUNA Java Mobile 4

- Les télévisions (Android TV)

IV. Les versions de l’Android

Pr. Fouad AYTOUNA Java Mobile 5

VI. Architecture Android

VII. Dalvik et ART

VIII. SDK Android

IX. Compilation et déploiement

Pr. Fouad AYTOUNA Java Mobile 6

2. AVD: le gestionnaire d'appareils

XI. Structure projet Android

 res/layout/ : comprendra tous vos fichiers XML correspondant à vos layouts,

Pr. Fouad AYTOUNA Java Mobile 7

Déclare le niveau minimum de compatibilité du SDK pour que l'application fonctionne.

Pr. Fouad AYTOUNA Java Mobile 8

Les composants de base de

Pr. Fouad AYTOUNA Java Mobile 9

Table des matières

1. Exercice d’application : ...................................................................................... 12

III. EditText .............................................................................................................. 12

2. Exercice d’application ........................................................................................ 13

IV. Button ................................................................................................................. 14

3. Exercices d’application : .................................................................................... 15

Pr. Fouad AYTOUNA Java Mobile 10

I. Les annonces Toast

 Le premier paramètre représente l’activité courante.

Exemple 1 : Au chargement de l’écran un message sera affiché.

Pr. Fouad AYTOUNA Java Mobile 11

Voici un exemple d’accès à un TextView en utilisant le code JAVA. Le TextView posséde le

public class MainActivity extends AppCompatActivity {

Pr. Fouad AYTOUNA Java Mobile 12

android:textStyle Cet attribut peut contenir les valeurs suivantes :

Android :hintColor Permet de spécifier un couleur au texte hint

Voici un exemple d’accès à un EditText en utilisant le code JAVA. Le EditText posséde le

public class MainActivity extends AppCompatActivity {

Pr. Fouad AYTOUNA Java Mobile 13

Nous avons 2 méthodes pour traiter l’événement click du button :

public class MainActivity extends AppCompatActivity {

public class MainActivity extends AppCompatActivity implements Button.OnClickListener{

Pr. Fouad AYTOUNA Java Mobile 14

public void onClick(View v) {