Dossier bac ( PDF - 724 ko) - Mathématiques au lycée Bellepierre

ISN
Informatique et Science du Numérique
Projet de
développement
d'un logiciel de prêt
sous Android
Soupramayen Thomas
Rivière Nathan
Galiay Romain
2012/2013
TS3 du Lycée Bellepierre
Sommaire
Introduction..........................................................................................................page 1
Rechercher des formules de calculs..................................................................page 1-2
Première ébauche..............................................................................................page 2-4
Création du menu..............................................................................................page 5-8
Design...................................................................................................................page 8
Conclusion............................................................................................................page 9
Introduction
Nous allons vous présenter notre projet consistant à développer un logiciel de calcul de prêt sous
Android. Le choix du projet de développement était vaste. Au départ, nous étions tenté par le développement
du jeu Pong ou d'une calculatrice. Cependant, d'autres élèves étaient intéressés par ces projets. De plus, nous
recherchions un projet ambitieux qui ne serait pas trop aisé mais qui resterait tout de même accessible à nos
compétences. Nous n'avions aucune idée de ce que représentait un logiciel de prêt au début. Nous fûmes
donc contraints de faire de nombreuses recherches à ce sujet.
Afin de commencer la programmation, nous nous sommes aidé d'un logiciel libre : Eclipse. Nous avons pu le
télécharger sur le site de Google destiné aux développeurs Android où un dossier contenant tous les outils
nécessaires à ce développement était distribué gratuitement. L'url du site est la suivante :
http://developer.android.com/sdk/index.html. Sans ce dernier, nous aurions du installer Eclipse puis les addons servants à la programmation sous Android qui s’avère assez compliqué sur certains aspects.
L'installation n'a pas été très ardue puisque tout était préalablement configuré. Nous n'avions plus qu'à nous
lancer dans le développement de l'application qui nous semblait pour le moins long et complexe.
Notre projet s'est plus ou moins décomposé en trois parties. Nous avions développé dans un premier temps
une application test en se penchant sur un design simple d'application grâce au fichier XML. Puis nous nous
sommes concentrés sur la partie JAVA pour afin d'aboutir sur une application pour le moins fonctionnelle,
calculant dans un premier temps la mensualité à payer. Ensuite nous avons cherché à étoffer l'application en
ajoutant un menu menant vers différentes options afin de calculer d'autres paramètres du prêt. Enfin, nous
nous sommes intéressé de nouveau au design de l'application tout en restant dans la simplicité.
Recherches des formules de calcul
Nous devions rechercher les formules permettant de calculer :
-Le mensualité à payer, notée M (en euros)
-Le taux, notée T (en pourcentage)
-Le capital emprunté, notée C (en euros)
-La durée du crédit, notée D (en mois)
Au terme de nos recherches, plusieurs formules nous sont apparues. Il nous a donc fallu les trier afin de
garder les bonnes qui sont les suivantes :
T
12
T
1− 1+
12
C×
M=
−D
[ ]
C=
T
12
)
T
12
[ ]
C × 1+
D=
−D
[ ]
M ×(1− 1+
T
12
M
.1.
Ces formules étaient accessibles sur les sites suivants :
- http://www.formulecredit.com/faq-credit/calcul-remboursement-credit-91
- http://www.maths-forum.com/formule-financiere-calculer-duree-d-un-emprunt-3671.php
- http://www.ilemaths.net/calcul-credit.php
Nous avions trouvé une formule permettant de calculer le taux. Cependant, après conseil du professeur, nous
nous somme rendu compte que la formule sur laquelle nous nous étions basé était erroné. Nous avons donc
décider d'écrire un algorithme afin de calculer le taux. Ce dernier sera explicité ultérieurement.
Première ébauche
I) Fichier XML
Le fichier XML permet de gérer la partie graphique de l'application. A travers cette dernière, nous avons
créé l'interface servant à utiliser l'application. Pour cela, nous avons dû créer plusieurs champs servant à
saisir des informations. Les premiers champs créés furent ceux du capital, du taux et de la durée. Les champs
de saisies sont définis par « EditText » dans le langage XML. Puis nous avons placés des champs de texte
nommant les différents champs de saisies. Ces champs de texte sont définis par « TextView » dans le langage
XML. Ensuite, nous devions créer un bouton servant à lancer le calcul du prêt, définit simplement par
« Button ». Enfin, nous avons défini un autre « TextView » servant à l'affichage du résultat.
Voici le premier affichage graphique que nous avons créé grâce au XML:
Le code XML est composé de plusieurs parties (TextView, EditText, Button, ...). Ces parties définissent les
objets affichés à l'écran.
.2.
Voici une partie du code, définissant le TextView du Capital :
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="20dp"
android:text="Capital" />
→
→
→
→
→
→
→
→
type d'objet
nom attribué à l'objet
largeur de l'objet
hauteur de l'objet
alignement par rapport au haut
position par rapport à la ligne horizontale
position de l'objet par rapport au haut
contenu affiché par l'objet
Nous devions ensuite relier les différents objets au code écrit en java. Pour cela, nous avons utilisé une
fonction appelé « import », servant donc à relier les champs de saisies, les champs de textes et le bouton au
code JAVA.
Voici un exemple présent dans notre premier code :
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
Cependant, le bouton devait être relié à une fonction « OnClick » afin d'interagir avec le code JAVA. Pour
cela, nous avons utilisé la ligne de code suivante :
public void Calcul(View v){
Après avoir défini l'interface de l'application, nous avions à nous concentrer sur le cœur de l'application,
autrement dit la partie JAVA.
.3.
II) Fichier Java
Le code JAVA se structure à la manière d'un algorithme, mais le langage utilisé dans le code est propre à la
programmation Android, donc différent de celui utilisé pour les algorithmes en général. Nous avons donc,
dans un premier temps, déclaré les objets que nous allions utiliser afin d'écrire le code :
public class Pret extends Activity
{
TextView affichage=null;
EditText capital=null;
EditText taux=null;
EditText durée=null;
float n;
}
→ nom de l'activité suivie du type de l'activité
→ valeur par défaut de la variable « affichage »
→ valeur par défaut de la variable « capital »
→ valeur par défaut de la variable « taux »
→ valeur par défaut de la variable « durée »
→ déclare la variable « n » comme nombre décimal
Par la suite, nous avons dû associer les variables aux objets XML :
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pret);
affichage =(TextView)findViewById(R.id.textView4);
capital=(EditText)findViewById(R.id.editText1);
taux =(EditText)findViewById(R.id.editText2);
durée =(EditText)findViewById(R.id.editText3);
}
→permet de sauver les déclarations
→réfère au fichier XML « activité_pret »
→associe la variable au résultat affiché dans le« textView4 »
→associe la variable à ce que l'utilisateur a entré dans l'« editText1 »
→associe la variable à ce que l'utilisateur a entré dans l'« editText2 »
→associe la variable à ce que l'utilisateur a entré dans l'« editText3 »
Nous avons cependant eu quelques confusions lors de l'association des variables aux différents « editText »
numérotés. De plus, nous devions être minutieux en respectant les majuscules puisque « editText » s'écrit
également « EditText » dans d'autres parties du code. Cette erreur fut fréquente à nos débuts.
Enfin, nous avons défini les paramètres du calcul ainsi que le calcul lui même :
public void Calcul(View v){
Integer c=Integer.valueOf(capital.getText().toString());
Float t=Float.valueOf(taux.getText().toString())/100
Integer d=Integer.valueOf(durée.getText().toString());
n=(float)Math.round(c*t/12/(1-Math.pow(1+t/12-d))*100)/100;
affichage.setText(n+ " = Voila votre prêt");
→ définition de la variable c
→ définition de la variable t
→ définition de la variable d
→ calcul de n
→ affichage du résultat
L'écriture du calcul de « n » ne fut pas simple car nous devions intégrer « Math.round » dans la ligne de
code. Dans le cas contraire, le calcul ne pouvait fonctionner.
Notre première application servait simplement à calculer la mensualité. Afin de la compléter et de remplir le
cahier des charges, nous nous sommes lancés dans le développement d'un menu afin d'avoir plusieurs pages
permettant ainsi de calculer les différents paramètres.
.4.
Création du menu
I) Premier menu « option »
Pour notre premier menu, nous avons choisi de créer une autre application, pour comprendre
comment faire un menu, avant de l'intégrer à l'application finale. Il existe une multitude de façon de créer un
menu. Ainsi, afin d'aboutir à un menu correct, nous avons essayé plusieurs méthodes, dont certaines
utilisaient plus le langage XML que le JAVA et vice-versa. Au final, pour notre menu, nous nous sommes
basés essentiellement sur du JAVA et très peu sur le XML.
Dans le menu final, que nous avons utilisés pour l'application, la majeure partie s'est construite dans
le JAVA. Tout d'abord, il a fallu créer autant de fichiers JAVA que de pages souhaitées. Ensuite, nous avons
dû déclarer ces pages comme activités. Pour cela, nous avons travaillé le fichier XML et plus
particulièrement, le fichier « AndroidManifest.xml ». Ce fut la seule fois où nous avons utilisés le XML. Puis,
le menu s'est construit en trois parties dans le fichier JAVA. Premièrement il a fallu créer les cases qui vont
par la suite composer le menu.
Puis, il a fallu faire appel à la fonction «onCreateOptionsMenu», qui a ainsi permis de créer le menu, présent
sur la page appelé. Par la suite, il a fallu associer les cases déclarées un peu plus haut dans le code, au nom
que l'on souhaitait voir affiché lorsque l'utilisateur fait appel au menu.
.5.
Enfin, il a fallu associer des actions aux cases comme par exemple, le changement de page. Dans notre cas,
chaque case permet de changer de page, il y a aussi un message qui s'affiche lorsque l'utilisateur appui sur
l'une des cases, pour signaler une attente, puisque certains téléphones, peuvent avoir des ralentissements lors
du changement de la page.
Cependant, pour une question d'ergonomie et d'accessibilité au démarrage de l'application nous avons
décider de créer un sommaire menant vers les différentes pages de calcul.
II) Création d'un sommaire
Notre sommaire fut donc composé de quatre boutons menant les paramètres suivants : capital, durée,
mensualité et taux. Ces quatre boutons furent placés grâce au fichier XML de la même façon qu'expliqué
précédemment. Voici l'affichage graphique de notre sommaire ainsi qu'un extrait du fichier XML :
.6.
Nous avons dû ensuite développer la partie JAVA. Pour cela, nous devions simplement relier les boutons aux
différentes pages créées après avoir déclaré ces derniers de la même façon qu'expliqué précédemment.
Puis nous devions associer chaque bouton à une action. En effet, grâce à la fonction « OnClickListener »
nous avons associé chaque bouton à la page prévue afin que l'utilisateur puisse accéder à la page souhaitée
lors du clique sur le bouton.
.7.
Après avoir créé le sommaire, le menu et les pages de calcul des différents paramètres associés, nous nous
sommes rendus compte que notre calcul du taux était erroné d’après le professeur. Ainsi, a près avoir créé les
pages servants à calculer la durée du prêt, le capital à emprunter, la mensualité, nous devions créer un
algorithme afin de calculer le taux. Ce dernier était basé sur le calcul de la mensualité à partir d'un taux
initial de 0,001%. En effet, notre algorithme devait retrouver la mensualité entrée par l'utilisateur grâce à une
boucle augmentant de 0,001 % à chaque calcul tant que la mensualité était différente de celle entrée par
l'utilisateur. L'algorithme se traduit ainsi :
VARIABLES :
m: réel
c: réel
d: réel
n: réel
DEBUT :
m prend la valeur entrée dans « mensualité »
c prend la valeur entrée dans « capital »
d prend la valeur entrée dans « durée »
t=0,0001
Tant que (M<m) :
M=(c*t/12)/(1-(1-t/12)^-d)
t prend la valeur t+0,0001
Si (M>m) :
n prend la valeur t*100
Afficher n
Nous avons par la suite traduit l'algorithme en JAVA pour aboutir au code suivant :
Double m=Double.valueOf(mensualité.getText().toString());
Integer c=Integer.valueOf(capital.getText().toString());
Float d=Float.valueOf(durée.getText().toString());
t=0.0001;
while (M<m){
M=(c*t/12)/(1-Math.pow(1+t/12,-d));
t=t+0.0001;
if (M>=m){
n=(float)(t *100);
affichage.setText(n + "% = Voila le taux");
Enfin, après avoir réussi à obtenir une application fonctionnelle correspondant plus ou moins au cahier des
charges, nous avons décidé de nous attarder sur le design de l'application.
Design
Pour commencer, nous avons changé le fond d'écran en optant pour un dégradé gris. Pour cela nous avons
téléchargé le fond choisi puis nous l'avons placé dans le dossier « res/drawable-hdpi » de l'application.
Ensuite nous avons associé le fond à chaque page via leur fichier XML grâce à la fonction
« android:background= « @drawable/gradient » (« gradient » étant le nom de notre image).
Par la suite, nous avons pensé astucieux d'inhiber la rotation de l'écran afin de maintenir l'affichage prévu.
Pour cela nous avons utilisé la fonction « android:screenOrientation» dans l'AndroidManifest, et ce pour
chaque activité.
Puis noush avons voulu grossir la taille des objets XML, en modifiant simplement leur taille grâce aux
fonctions « android:layout_width » et « android :layout_height » et dans le fichier XML de chaque objet.
Enfin, afin de finir l'application nous avons pensé à changer l’icône de l'application. Après avoir téléchargé
l'image voulue, il a fallu remplacer l’icône de base par notre image dans le dossier « res/drawable-hdpi ».
.8.
Conclusion
En conclusion, nous pouvons affirmer que nous sommes heureux d'avoir abouti à l'application que nous
voulions au départ que ce soit dans les fonctionnalités ou dans l'ergonomie. Il ne fut pas aisé d'arriver à ce
résultat puisque nous avons dû passé plusieurs heures par semaine à travailler cette application, d'autant plus
que le temps ne nous le permettait pas toujours. Nous pouvons dire que ce projet a été enrichissant du fait
que au départ nous n'avions aucune idée ou très peu de ce que représentait la programmation sous Android.
Même si nous avions quelques bases qui nous ont en outre permis de développer en majeure partie la
première version de l'application, nous étions loin de maîtriser toutes les bases. Grâce à ce projet, nous avons
aujourd'hui un peu plus de recul sur comment est construite une application Android, comme nous en avons
l'habitude d'utiliser au quotidien. De plus, nous sommes fier de posséder aujourd'hui sur notre smartphone
une application fonctionnelle sur laquelle nous avons travaillé entièrement. Le code source nous servira
sûrement à l'avenir de support afin de développer d'autres applications. De plus, nous envisageons plus tard
de distribuer notre application via le PlayStore d'Android.
Webographie :
Afin de développer cette application, nous nous somme entièrement basé sur le site suivant:
http://developer.android.com/develop/index.html ainsi que sur le informations acquises en cours et
données par le professeur.
.9.