creating application android

							Sommaire


I. Présentation d’Android
II. Installation de l’SDK Android
III. Création et utilisation de l’émulateur
IV. Première application Android
V. Les perspectives :
1. DDMS : Dalvik Debug Monitor Server
2. Le logCat :
VI. Vue d’ensemble
1. Activités
2. Les sous Activités
3. Les menus
4. Les layouts
5. Les ressources
I - Présentation d’Android
      Android est   un système    d'exploitation open source3 utilisant  le noyau  Linux,
      pour smartphones, PDA et terminaux mobiles conçu par Android, une startup rachetée
      par Google, et annoncé officiellement le 5 novembre 2007. D'autres types d'appareils
      possédant ce système d'exploitation existent, par exemple des téléviseurs et des
      tablettes.




      Android est la première plateforme open source entièrement paramétrée. Des
      trentaines de compagnie attribut à Android à travers Open Handset Alliance ; L'Open
      Handset Alliance (abrégé OHA) est un consortium de plusieurs entreprises dont le but
      est de développer des normes ouvertes pour les appareils de téléphonie mobile.



      Le consortium a été créé le 5 novembre 2007 à l'initiative de Google qui a su fédérer
      autour de lui 34 compagnies (En 2008. Voir le lien sur les membres actuels). On note
      ainsi la présence d'opérateurs comme NTT DoCoMo, Sprint Nextel, Telecom
      Italia ou Bouygues Telecom. Des équipementiers tels que Samsung, Motorola ou LG
      Electronics. Des semi-conducteurs comme Intel ou Nvidia. Et enfin des incontournables
      de l'Internet dont eBay. On remarquera quelques grands absents dont Nokia. Et pour
      cause. Le numéro 1 de la téléphonie mobile possède Symbian, un éditeur de systèmes
      d'exploitation pour portables. Cependant Nokia ne s'interdit pas d'entrer un jour dans le
      consortium



Plusieurs sites web sont essentiels pour le développeur Android :


www.openhandsetaliance.com/
www.source.android.com
www.android.com
www.developer.android.com site officiel de l’application.
www.pointgphone.com
www.android-france.fr
www.androlib.com




II - Installation de l’SDK Android
      •   Etape 1 : Préparer votre ordinateur :




                                               2
Avant de télécharger le SDK Android, prenez un moment pour s’assurer que votre
ordinateur répond aux exigences de développement. En particulier, vous pourriez avoir
besoin d'installer le JDK, si vous ne l'avez pas déjà.
Lien               de              téléchargement        du                       jdk
http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u4-downloads-
1591156.html

      •   Etape 2 : Télécharger Eclipse

La 2eme chose à faire est donc de télécharger l’environnement de développement Eclipse (si
ce n’est pas déjà fait).
Pour cela rien de plus simple, allez sur le site d’Eclipse http://www.eclipse.org/ et
téléchargez Eclipse IDE for Java Developers. Aucune installation n’est à réaliser il suffit
simplement de décompresser le fichier téléchargé et de faire un double clic sur le
fichier eclipse.exe pour lancer le logiciel.



      •   Etape 3 : Télécharger le SDK Android

Passons maintenant au téléchargement                du   SDK   Android   sur   le   site Android
http://developer.android.com/sdk/index.html.

Téléchargez la version pour Windows, et décompressez le fichier zip où vous le souhaitez sur
votre disque dur (exemple : C:\Android\android-sdk-windows).

Nous allons maintenant ajouter le chemin du SDK Android à la variable Path du système. Ceci
permettra d’utiliser les outils du SDK sans devoir spécifier le chemin complet à chaque fois.

Attention la manipulation est légèrement différente en fonction du système d’exploitation
Windows que vous utilisez.


      •   Etape 4 : Installation du plugin Android pour Eclipse

Lancez Eclipse, puis allez dans le menu Help > Install New Software, puis cliquez sur le
bouton Add et remplissez le formulaire.

Dans le champ Name écrivez par exemple Plugin Android et dans le champs
Location indiquez l’adresse suivante : https://dl-ssl.google.com/android/eclipse/ puis
cliquez sur OK.

En cas de problème, remplacez https par http.




                                                3
Cochez Developer Tools puis cliquez sur Next (à deux reprises). Cochez « I accept the
terms of the license agreements » puis cliquez sur Finish.




Une fois l’installation terminée, redémarrez Eclipse.

Au redémarrage, allez dans le menu Windows >Préférences > Android puis SDK
Location, cherchez le dossier dans lequel se trouve le SDK que vous avez décompressé

                                                4
précédemment (dans notre cas il s'agit de C:\Program Files\Android\android-sdk) puis cliquez
sur OK.




Le SDK Android et le plugin Android pour Eclipse sont maintenant installés. Il ne reste plus
qu’à configurer le plugin avec le SDK.


Etape 5 : Configuration du plugin Android

Cliquez sur la petite icône avec une flèche pointant vers le bas (4 ème icône à partir de la
gauche)




Cliquez sur Installed Packages puis sélectionnez le package Android SDK Tools et cliquez
sur Update All.




                                             5
Cochez Accept All puis cliquez sur Install.




Vous êtes maintenant prêt à programmer des applications Android.




III - Création et utilisation de l’émulateur


Pour exécuter vos projets Android il vous faut un émulateur. Pour le créer un cliquez sur
l’icône avec un terminal mobile (la 6ème depuis la gauche)




La fenêtre suivante sera affichée




                                              6
Cliquez sur new




Vous devez spécifier le nom de l’émulateur : Name, la version d’android : target sdk, la
taille de la sdcard est optionnelle. Vous devez aussi préciser la résolution de l’émulateur dans
le champs skin.




                                                7
Puis cliquer sur create AVD

Votre émulateur est prêt pour tester vos applications Android.




IV - Première application Android


L’environnement d’installation est prêt, nous allons maintenant créer notre première
application Android.

Cliquer sur l’icône suivante :




Spécifiez le nom de l’application




                                              8
Spécifier la version Android que vous allez utiliser:




Puis préciser le nom du package, il représente l’identifiant unique de l’application, donc il doit
être unique pour chaque application.



Ajoutez le nom de l’activité qui va être par défaut la première activité lancée au démarrage de
l’application




                                                 9
Cliquez ensuite sur finish.

Maintenant notre premier projet est crée. Pour le lancer, cliquez sur l’icône ci dessus :




Choisir Android Application:




Puis cliquez sur ok

Notre première application est lancé.




                                              10
Reprenons notre projet exemple PremiereApp que nous avons lancé précédemment.

La structuration d’un projet Android se base sur la notion de convention et vous devrez la
respecter pour que votre projet puisse être compilé et packagé.

C’est pourquoi il est conseillé d’utiliser les wizards mis à disposition dans les IDE.

Projet Android : c’est le type de projet le plus répandu. Il contient tous les éléments qui
permettront de construire l’archive apk qui contiendra tous les éléments nécessaires à la
bonne exécution de votre application.

Voici la structure de notre projet :




            Répertoire                          Ce répertoire contient
      src                   Tous vos fichiers de sources .java et .aidl (Android Interface
                            Definition Language)
      bin                   Les fichiers compilés et archives
      jni                   Le code source natif android généré par NDK

                                                11
      gen                     Les fichiers générés par ADT comme le fichier R.java pour
                              les ressources
      assets                  On peut utiliser ce répertoire pour stocker des données via la
                              classe AssetManager
      res                     Les ressources de l’application
      res/anim                Les fichiers XML qui sont compilés en objet Animation
      res/color               Les fichiers XML qui décrivent les couleurs
      res/drawable            Les fichiers images png, jpeg, gif
      res/layout              Les fichiers XML décrivant les parties d’écran
      res/menu                Les fichiers XML décrivant les menus
      res/raw                 Les fichiers média utilisés par l’application
      res/values              Les fichiers XML contenant toutes les chaines de caractères
                              utilisées dans l’application ou les URI
      res/xml                 Les fichiers XML de configuration de l’application
      libs                    Les librairies privées
      AndroidManifest.x       Fichier de description de l’application
      ml
      project.properties      Fichier de description du projet Eclipse
      ant.properties          Propriétés utilisés dans le fichier suivant
      build.xml               Fichier ant de construction du projet


Structure de fichier R.java




                                                   12
Structure du fichier main.java




La fonction Oncreate permet de lancer notre activité au démarrage de l’application.

Structure du fichier Strings.xml

Ce fichier permet de constituer vos ressources String, tableaux de string, dimensions.
Le fichier possède une interface graphique permet de faciliter la création vos ressources.
Par exemple ici on va ajouter une ressource string name qu’on va utiliser plus tard.




Structure du fichier main.xml

Passons maintenant au fichier main.xml. Le dossier layout permet de décrire comment
l’activité sera affichée pour les utilisateurs.

Le layout xml est une interface d’aide pour préciser les vues et leurs positionnement.

Ajouton par exemple à notre interface un buttom et un chekbox :

Notre fichier main.xml :




                                               13
Sur l'émulateur l’application sera affichée ainsi :




V- Les perspectives :


          1. DDMS : Dalvik Debug Monitor Server

Plusieurs fonctionnalités sont offertes par le plugin Android, elles s’appellent perspectives,
parmi ses fonctionnalités on trouve DDMS c’est une interface qui vous permet d’interagir avec
votre téléphone ou votre émulateur :




                                                14
A gauche nous avons une fenêtre « Device » qui affiche tous les émulateurs et téléphones
connectés à l’ordinateur.

En cliquant sur le processus qu’on veut : on peut débugger le processus, voir la liste des
threads, la mémoire, arrêter le processus et faire des captures d’écran.

A droite nous avons plusieurs fenêtres notamment la fenêtre « files explorer » qui permet
de visualiser les fichiers du téléphone et par la suite importer et exporter des fichiers.

En bas nous avons une fenêtre pour contrôler le téléphone, envoyer un appel téléphonique,
envoyer un sms ou bien préciser les coordonées GPS.

         2. Le logCat :

Le « logCat » permet de visualiser en temps réel les messages provenant du débogueur et
de l’émulateur.




L’interface de « logCat » permet de filtrer les messages par leurs niveaux : erreur, info,
warning.

Vous pouvez aussi créer vos propres filtres par tags, message log, processus ou par nom
d'application

                                            15
VI - Vue d’ensemble


          1. Activités :

Une activité est la composante principale d'une application sous Android. L'activité est le
métier de l'application et possède généralement une View au minimum, c'est à dire un écran
graphique. Ainsi dans une application standard, on pourrait trouver une activité qui liste des
contacts, une activité qui ajoute un nouveau contact, et une activité qui affiche le détail d'un
contact. Le tout forme un ensemble cohérent, mais chaque activité pourrait fonctionner de
manière autonome.
NB : Nous pouvons avoir plusieurs activités dans le même programme.
En général, une activité se trouve toujours dans l’un des quatre états suivants :

● Active. L’activité a été lancée par l’utilisateur, elle s’exécute au premier plan. C’est à cet
état que l’on pense quand on évoque le fonctionnement d’une activité.

● En pause. L’activité a été lancée par l’utilisateur, elle s’exécute et elle est visible, mais une
notification ou un autre événement occupe une partie de l’écran. Pendant ce temps,
l’utilisateur voit l’activité mais peut ne pas être capable d’interagir avec elle.

Lorsqu’un appel téléphonique est reçu, l’utilisateur a l’opportunité de prendre cet appel ou de
l’ignorer, par exemple.

● Stoppée. L’activité a été lancée par l’utilisateur, elle s’exécute mais est cachée par d’autres
activités qui ont été lancées ou vers lesquelles le système a basculé. Votre application ne
pourra rien présenter d’intéressant à l’utilisateur directement : elle ne peut passer que par
une Notification.

● Morte. L’activité n’a jamais été lancée (le téléphone vient d’être réinitialisé, par exemple) ou
elle a été tuée, probablement à cause d’un manque de mémoire.




                                                 16
Figure 1 cycle de vie d'une Activité

Voyons maintenant le cycle de vie d’une activité en code : main.java
      public class main extends Activity {
            /** Called when the activity is first created. */
            @Override
            public void onCreate(Bundle savedInstanceState) {
                  super.onCreate(savedInstanceState);
                  setContentView(R.layout.main);
                  Log.i("cycle", "onCreate");
            }

             @Override
             protected void onRestart() {
                  super.onRestart();

                                             17
                   Log.i("cycle", "onRestart");
             }

             @Override
             protected void onStart() {
                  super.onStart();
                  Log.i("cycle", "onStart");
             }

             @Override
             protected void onResume() {
                  super.onResume();
                  Log.i("cycle", "onResume");
             }

             @Override
             protected void onPause() {
                  super.onPause();
                  Log.i("cycle", "onPause");
             }

             @Override
             protected void onStop() {
                  super.onStop();
                  Log.i("cycle", "onStop");
             }

             @Override
             protected void onDestroy() {
                  // TODO Auto-generated method stub
                  super.onDestroy();
                  Log.i("cycle", "onStop");
             }

      }


          2. Les sous Activity :

Maintenant nous allons voir comment lancer une sous activité à partir d’une activité
principale.
Premièrement nous allons créer notre interface graphique dans le fichier main.xml : créons un
« button » et un « textView »




Maintenant nous allons faire appel à nos éléments d’interface graphique dans notre activité :
          1. Déclaration des vues

                                                  18
               Button button;
               TextView textView;


          2.   Dans la fonction onCreate nous allons chercher nos objets dans les ressources :

               button=(Button) findViewById(R.id.button1);
               textView=(TextView) findViewById(R.id.editText1);


          3.   Mettre en place un « listener » sur notre « buttom »

        button.setOnClickListener(this);


          4. Dans la fonction onClick appeler la sous activité

        @Override
             public void onClick(View v) {
                   Intent intent=new Intent(this,main.class);
                   startActivityForResult(intent, 1000);
             }


          5. Pour passer un paramètre à une sous activité entrez :

             intent.putExtra("nom", "jos atelier Android");
          6. Pour récupérer le paramètre envoyé à l’application tapez

        if(this.getIntent().getExtras()!=null)
        textView.setText(this.getIntent().getExtras().getString("nom"));



          7.   Pour Récupérer le coderequest de l’activité fille redéfinir la méthode
               « onActivityResult » ainsi

        @Override
              protected void onActivityResult(int requestCode, int resultCode, Intent
        data) {
                   super.onActivityResult(requestCode, resultCode, data);
                   Toast.makeText(this, ""+requestCode, 1000).show();
              }



Activité principale :




                                                 19
Si on clique sur le « button » sous activité : la sous activité se lance, et le paramètre envoyé
par l’activité mère est affiché dans le « textView».




Pour lancer une sous activité, il n’est pas toujours nécessaire d’utiliser la même Activité, vous
pouvez aussi créer une autre. Voici les étapes :




         1.   Créer votre activité main2.java.

       public class main2 extends Activity {
             @Override
             protected void onCreate(Bundle savedInstanceState) {
                   super.onCreate(savedInstanceState);
             }
       }


         2.   Déclarer l’activité dans le manifest.xml ainsi :

              <activity android:name="main2"></activity>


         3.   Créer un layout main2.xml :




         4.   Puis changer le code de la méthode onClick ainsi :

Intent intent=new Intent(this,main2.class);
intent.putExtra("nom", "jos atelier Android");
startActivityForResult(intent, 1000);


              2 Les menus :

Les activités Android peuvent comprendre des menus, comme les applications de bureau et
de certains systèmes mobiles.


                                                 20
Android distingue les "menus d’options" des "menus contextuels". Les premiers se
déclenchent en appuyant sur le bouton "Menu" du terminal, tandis que les seconds s’ouvrent
lorsqu’on maintient une pression du doigt sur le widget qui dispose de ce menu.

En outre, les menus d’option fonctionnent selon deux modes : icône et étendu. Lorsque
l’utilisateur appuie sur le bouton Menu, le menu est en mode icône et n’affiche que les six
premiers choix sous la forme de gros boutons faciles à sélectionner, disposés en ligne en bas
de l’écran. Si ce menu compte plus de six choix, le sixième bouton affiche "Plus" – cliquer sur
cette option fait passer le menu en mode étendu, qui affiche tous les choix restants.
L’utilisateur peut bien sûr faire défiler le menu afin d’effectuer n’importe quel choix.

          1.    Les menus d’options:
Pour créer un menu vous devez redéfinir la méthode « onCreateOptionsMenu » ainsi :
 @Override
   public boolean onCreateOptionsMenu(Menu menu) {
       onCreateMenu(menu);
       return super.onCreateOptionsMenu(menu);
   }

   private void onCreateMenu(Menu menu){
      SubMenu m = menu.addSubMenu(0, 2000, 0, "Sous menu 1");
      m.add(0,1000,0,"Menu 1").setChecked(true).setCheckable(true);
      m.add(0,1001,0,"Menu 2").setEnabled(false);
      m.setIcon(android.R.drawable.ic_menu_call);
      m.setHeaderIcon(android.R.drawable.ic_menu_agenda);
   }

Explication :

SubMenu m = menu.addSubMenu(0, 2000, 0, "Sous menu 1"); : permet de créer un menu
parent avec un code de 2000.
m.add(0,1000,0,"Menu 1").setChecked(true).setCheckable(true); : permet d’ajouter un sous
menu au menu parent.

m.setIcon(android.R.drawable.ic_menu_call); : permet d’ajouter une icône au menu.
m.setHeaderIcon(android.R.drawable.ic_menu_agenda); : permet d’ajouter une icône en tête
de la liste des sous menus.




                                               21
Puis redéfinir la méthode onOptionsItemSelected qui gère le click sur le menu:
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch(item.getItemId()){
        case 1000:
               Toast.makeText(this,"Menu 1",1000).show();
               break;
        case 1001:
               Toast.makeText(this,"Menu 2",1000).show();
               break;
        }
        return super.onOptionsItemSelected(item);
    }


Explication :
 L’instruction « item.getItemId() » : permet de récupérer le code du menu sélectionné.

Si vous devez modifier le menu au cours de l’activité (pour, par exemple, désactiver un choix
devenu inadéquat), il suffit de manipuler l’instance de Menu que vous avez transmise à
onCreateOptionsMenu ou d’implémenter la méthode onPrepareOptionsMenu, qui est
appelée avant chaque affichage du menu.

Par exemple :
 @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
       menu.findItem(2000).setTitle(""+SystemClock.elapsedRealtime());
       return super.onPrepareOptionsMenu(menu);
    }



      3 Les menus contextuels:



Pour créer un menu contextuel on va procéder ainsi

         1.   Définir le layout qui va afficher le menu contextuel

        view = ((LinearLayout)this.findViewById(R.id.view1));

         2.   Ajouter les listeners nécessaires:

        view.setOnLongClickListener(this);
               view.setOnCreateContextMenuListener(this);


                                                   22
        3.   Redéfinir la méthode onCreateContextMenu
      @Override
      public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo
      menuInfo) {
                  onCreateMenu(menu);
                  super.onCreateContextMenu(menu, v, menuInfo);
            }
        4. Redéfinir la méthode onContextItemSelected
      @Override
           public boolean onContextItemSelected(MenuItem item) {
                 switch(item.getItemId()){
           case 1000:
                 Toast.makeText(this,"Context Menu 1",1000).show();
                 break;
           case 1001:
                 Toast.makeText(this,"Context Menu 2",1000).show();
                 break;
           }
                 return super.onContextItemSelected(item);
           }

        5.   Redéfinir la méthode onLongClick
      public boolean onLongClick(View v) {
                 v.showContextMenu();
                 return false;
            }

             4 Les layouts :

Le layout est un fichier XML qui permet de déterminer le positionnement des vues de
l’interface graphique utilisateur.
Un layout peut contenir d’autres layouts imbriqués qui continent eux même des vues :




Nous allons maintenant créer un projet Android, dans notre Activité principale nous allons
créer notre layout:
                                   LinearLayout layout;

                                             23
Nous allons créer ensuite 2 méthodes pour créer un button et une zone de texte :
      private TextView createTextView(){
                    TextView view = new TextView(this);
                    view.setText("Bonjour");
                    return view;
      }

       private Button createButton () {
                   Button view = new Button(this);
                   view.setText("Bonjour");
                   return view;
       }

Nous allons redéfinir la méthode onCreate ainsi :

    @Override
      public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.main);

           layout = new LinearLayout(this);
           layout.addView(createTextView());
           layout.addView(createButton());

           layout.setOrientation(LinearLayout.VERTICAL);
           layout.setGravity(Gravity.RIGHT);

           setContentView(layout);

       }

   Explication :

layout = new LinearLayout(this); : pour créer un LinearLayout en lui donnant en paramètre
l’activité courante en context.
layout.addView(createTextView()); : pour ajouter un textView (champs texte) a notre layout
layout.setOrientation(LinearLayout.VERTICAL) : pour définir l’orientation des vues : vertical.
layout.setGravity(Gravity.RIGHT) : pour définir la gravité c.-à-d. le positionnement des vues
au sein du layout : droit, gauche, haut, bas.
setContentView(layout); : définir notre layout comme la vue principal.

Nous pouvons aussi définir une image comme arrière plan de notre layout :

 BitmapDrawable bmp =
 (BitmapDrawable)this.getResources().getDrawable(R.drawable.back);
 layout.setBackgroundDrawable(bmp);

Et voici le résultat de notre projet :




                                               24
Lorsqu’on fait tourner l’émulateur : l’image se redimensionne pour qu’elle puisse prendre les
dimensions de l’écran de l’émulateur, et les vues gardent leur gravité : right.




         1. Les ressources :

Dans cet atelier nous allons voir comment créer et exploiter les ressources dans un projet
Android.

Dans le dossier ressources (res), existe plusieurs types de ressources : les animations, les
images, les layouts, les values qui sont des fichiers xml de tableaux, de dimensions, de chaine
de caractères, ou bien de style personnalisés. Dans le fichier raw nous plaçons toutes les
données brutes, les fichiers audios, vidéos ou autres fichiers multimédia.

Nous ne pouvons pas accéder directement à ces fichiers, nous allons donc utiliser un
getRessource, cette méthode accède à toutes les ressources d’une application Android.




                                              25
Dans la méthode onCreate de l’activité principale, nous allons accéder à nos ressources ainsi :

int clr = this.getResources().getColor(R.color.demo);
String str     = this.getResources().getString(R.string.hello);
String[] arr = this.getResources().getStringArray(R.array.demo);
float dim      = this.getResources().getDimension(R.dimen.demo);
int[] ari      = this.getResources().getIntArray(R.array.demo);
String nam = this.getResources().getResourceEntryName(R.array.demo);
BitmapDrawable bmp = (BitmapDrawable)this.getResources().getDrawable(R.drawable.demo);


Nous pouvons aussi récupérer nos ressources sous forme de flux en utilisant un inputStream :

InputStream is = this.getResources().openRawResource(R.raw.demo);
DataInputStream dis = new DataInputStream(is);
try {
                  String text = dis.readLine();
                  Toast.makeText(this, text, 0).show();
} catch (Exception e) {
                  e.printStackTrace();
}


Nous pouvons aussi spécifier une animation a un textView :

(TextView)this.findViewById(R.id.text1).setAnimation(R.anim.demo);
     this.getResources().getAnimation(R.anim.demo);


                                               26
Conclusion

Nous espérons qu'à ce stade, vous êtes capable de créer une application android de base avec
ses activités, son menu, et son interface graphique.

Ce sont les bases nécessaires à la création de tout projet android.

Si ce domaine vous passionne, pour aller plus loin, nous vous conseillons de consulter la
documentation officielle du SDK Android, qui est à notre sens la plus complète.



Pour plus d'information n'hésitez pas à nous contacter :



                                                                      Casafree Web Agency

                                                     7 rue Jabal toubkal, n°5 Agdal, Rabat

                                                      Tél : 0537686460 Fax : 0537686666

                                                           Email : contact@casafreepro.com




                Bonne chance et bon développement !


                        L'équipe Casafree, mai 2012




                Document disponible en ligne sur le blog de l'entreprise
                           http://www.casafreepro.com




                                               27