Mobile Tutos

Nous verrons dans ce tuto qu’il existe 2 façons de sauvegarder des données dans un fichier sur Android. Vous êtes prêt ? Alors c’est parti !

Tout d’abord, on peut faire une sauvegarde interne dans la mémoire du téléphone ou bien faire une sauvegarde externe dans la carte SD de l’utilisateur.

Il faut savoir que les informations enregistrées dans la carte mémoire externe du terminal mobile sont accessibles par l’ensemble des applications.

Alors que les données sauvegardées en mémoire interne peuvent ou non être partagé en lecture ou/et en écriture avec les autres applications.

Voici la liste des différentes permissions pour la création d’un fichier dans la mémoire interne :

 MODE_PRIVATE crée un fichier (ou remplace l’existant), le fichier ne sera disponible que pour notre application.

 MODE_APPEND crée un fichier (concatène si le fichier existe)

 MODE_WORLD_READABLE accès en lecture par les autres applications

 MODE_WORLD_WRITEABLE accès en écriture par les autres applications

 MODE_WORLD_READABLE|MODE_WORLD_WRITEABLE accès en lecture et écriture par tous

Pour l’écriture nous allons utiliser la méthode openfileoutput qui va renvoyer un FileOUtputStream,

Pour la lecture il faut utiliser la méthode openFileInput qui renvoie un FileInputStream.

Nous allons mettre en place une application toute simple qui va jouer le rôle d’un bloc note.

L’utilisateur pourra écrire dans un fichier, mais également l’ouvrir et l’éditer.

En termes d’interface nous aurons :

• juste une zone de saisie.
• Un bouton pour enregistrer les modifications.
• Un bouton pour afficher le contenu de notre fichier.
• Un autre bouton pour vider la zone de saisie.

Ce qui se résume à ce code là :

<LinearLayout xmlns:android=« http://schemas.android.com/apk/res/android »

    android:layout_width=« fill_parent »

    android:layout_height=« fill_parent »

    android:orientation=« vertical » >

   <EditText

        android:id=« @+id/texte »

        android:layout_width=« fill_parent »

        android:layout_height=« wrap_content »

        android:lines=« 5 »

         android:gravity=« top|left » android:inputType=« textMultiLine »

        android:scrollHorizontally=« false » />

   <LinearLayout xmlns:android=« http://schemas.android.com/apk/res/android »

    android:layout_width=« fill_parent »

    android:layout_height=« fill_parent »

    android:orientation=« horizontal » >

    <Button android:id=« @+id/btn »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« Sauvegarder » />

    <Button android:id=« @+id/btn2 »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« Afficher » />

        <Button android:id=« @+id/btn3 »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« Vider » />

</LinearLayout>

</LinearLayout>

Pour l’enregistrement d’un fichier dans la mémoire interne du téléphone, Les deux méthodes qui vont nous intéresser sont

Pour l’écriture :

private void ecrireFicher(String nomFichier,String monText) {

             BufferedWriter writer = null;

             try {

                    File dir = getDir(« ToutMesFichiers »,MODE_PRIVATE);

                    File newfile = new File(dir.getAbsolutePath() + File.separator + nomFichier);

                    newfile.createNewFile();

                    writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(newfile)));

                    writer.write(monText);

             } catch (Exception e) {

                    e.printStackTrace();

             } finally {

                    if (writer != null) {

                           try {

                                  writer.close();

                           } catch (IOException e) {

                                  e.printStackTrace();

                           }

                    }

             }

       }

 Pour la lecture :

 private String lireFichier(String nomFichier) {

             File dir = getDir(« ToutMesFichiers »,MODE_PRIVATE);

             File newfile = new File(dir.getAbsolutePath() + File.separator + nomFichier);

             String monText= » »;

             BufferedReader input = null;

             try {

               input = new BufferedReader(new InputStreamReader( new FileInputStream(newfile)

                    ));

               String line;

               StringBuffer buffer = new StringBuffer();

               while ((line = input.readLine()) != null) {

                    buffer.append(line);

               }

                monText = buffer.toString();

             } catch (Exception e) {

                    e.printStackTrace();

             } finally {

             if (input != null) {

               try {

                    input.close();

                    } catch (IOException e) {

                           e.printStackTrace();

                    }

               }

             }

           return monText;

           }

Voici ce que le téléphone va créer dans le répertoire /data/data/ :

 Il faut ensuite mettre les écouteurs d’évènements à nos boutons. Voici le contenu de la méthode oncreate.

public void onCreate(Bundle savedInstanceState) {

             super.onCreate(savedInstanceState);

             setContentView(R.layout.main);

             final EditText text = (EditText) findViewById(R.id.texte);

             Button valider = (Button) findViewById(R.id.btn);

             valider.setOnClickListener(new OnClickListener() {                

                    public void onClick(View v) {                        

                           ecrireFicher(« monFichier.txt », text.getText().toString());

                    }

             });

             Button afficher = (Button) findViewById(R.id.btn2);

             afficher.setOnClickListener(new OnClickListener() {               

                    public void onClick(View v) {                        

                           text.setText(lireFichier(« monFichier.txt »));

                    }

             });

             Button vider = (Button) findViewById(R.id.btn3);

             vider.setOnClickListener(new OnClickListener() {                  

                    public void onClick(View v) {                        

                           text.setText(«  »);

                    }

             });

         }

Voici le résultat d’un scénario d’utilisation :

1. Un utilisateur rentre du texte 
2. Il sauvegarde le texte dans le fichier
3. Il vide le contenu de la zone de saisie
4. Il affiche le contenu de son fichier
5. Il modifie ce contenu
6. Il sauvegarde la modification
7. Il vide le contenu de la zone de saisie
8. Il affiche le contenu de son fichier

 Voici des images issues d’un autre scénario ou l’utilisateur n’enregistre pas ses modifications.

Utilisation de la carte SD

Nous pouvons faire la même application, mais les fichiers seront sauvegardés dans la mémoire externe du téléphone.

Ajouter la permission dans le manifest :

<uses-permission android:name= »android.permission.WRITE_EXTERNAL_STORAGE » />

NB : Pour les personnes utilisant l’émulateur, il faut monter une carte SD.

Rappel de la commande (à exécuter dans tools/) :

mksdcard 1024M sdcard.img

Dans runconfiguration, ajouter :

-sdcard C:\android-sdk-windows\tools\sdcard.img

 
Nous allons modifier nos deux méthodes :


Pour l'écriture :

private void ecrireFicher(String nomFichier,String monText) {

        File sdLien = Environment.getExternalStorageDirectory(); 

        File monFichier = new File(sdLien , "monFichier.txt");

        BufferedWriter writer = null;        

        try {

        FileWriter out = new FileWriter(monFichier); 

         writer = new BufferedWriter(out);          

         writer.write(monText); 

        } catch (Exception e) {

                       e.printStackTrace();

        } finally {

          if (writer != null) {

               try {

                       writer.close();

               } catch (IOException e) {

                       e.printStackTrace();

               }

          }

        }

  }

Pour la lecture :

private String lireFichier(String nomFichier) {

        String monText='';

        File sdLien = Environment.getExternalStorageDirectory(); 

        File monFichier = new File(sdLien + "/" +nomFichier); 

        if (!monFichier.exists()) {

               throw new RuntimeException("Fichier innéxistant dur la carte sd");

        } 

        BufferedReader reader = null;

        try {

               reader = new BufferedReader(new FileReader(monFichier));

               StringBuilder builder = new StringBuilder();

               String line;

               while ((line = reader.readLine()) != null) {

                       builder.append(line);

               }

             monText = buffer.toString();

        } catch (Exception e) {

               e.printStackTrace();

        } finally {

               if (reader != null) {

                       try {

                               reader.close();

                       } catch (IOException e) {

                               e.printStackTrace();

                       }

               }

        }

        return monText;

    }

Voici le contenu du répertoire /mnt/sdcard/

En répétant les mêmes scénarios d’utilisation que précédemment, nous obtiendrons les mêmes résultats.

Voilà ce qu’il en est de la sauvegarde de fichiers sur Android, j’espère que ce petit tuto vous servira pour vos applications futures 

Dans ce tuto, nous allons voir comment il est possible, comme le titre l’indique, d’améliorer notre navigation sur notre smartphone Android préféré en utilisant des tâches asynchrones via la classe AsyncTask ! Sur Android, l’ensemble des éléments graphiques sont gérés à partir d’un thread principal que certaines appellent « UI thread« . Il est donc déconseillé d’utiliser ce thread pour des opérations coûteuses ( requêtes en base, chargement d’éléments depuis le web … ).

 Il faut considérer que toute opération nécessitant un temps de traitement supérieur à 5 secondes sera considérée comme nuisible. Une boite de dialogue s’ouvrira alors pour informer l’utilisateur que l’activité ne répond pas. Pour mieux comprendre ce comportement, nous allons réaliser une petite application dont le but est de provoquer un ARN ( … et non ce n’est pas une maladie, ou un genre de crise ), ARN signifie simplement « Activity not Responding ».

Voici notre main.xml :

<?xml version="1.0" encoding="utf-8"?>   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="fill_parent"    android:layout_height="fill_parent"    android:orientation="vertical" >      <Button android:id="@+id/btn"    android:layout_width="wrap_content"    android:layout_height="wrap_content"    android:text="Valider" />      <EditText    android:id="@+id/edittext"    android:layout_width="fill_parent"    android:layout_height="wrap_content"/>   </LinearLayout>

Comme on peut le voir, on aura un bouton qui va lancer une opération et une zone de saisie qu’on va essayer d’utiliser durant le traitement de l’opération. 

Voici maintenant le code de notre activité :

public class AsyncTastActivity extends Activity {    /** Called when the activity is first created. */    @Override    public void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.main);    Button btn = (Button) findViewById(R.id.btn);    btn.setOnClickListener(new OnClickListener() {    public void onClick(View v) {    dormir();    }    });    }     private void dormir(){     try {     Thread.sleep(10000);     } catch (InterruptedException e) {     }     }    }

Testez maintenant votre code :

Lancez le programme, cliquez sur le bouton puis aussitôt, essayez de saisir un mot dans la zone de saisie. Vous verrez donc apparaître la fameuse boite de dialogue Activitiy not Responding.

Pendant le traitement, on ne peut pas faire autre chose comme taper du texte dans un champ.

Pour résoudre ce problème, on peut utiliser la classe AsyncTask. Cette classe sera notre carte maîtresse pour réaliser des tâches de manière asynchrone. Elle crée un deuxième thread de manière à ne pas bloquer le thread principal !

La classe prend 3 paramètres d’entrées.

• La paramètre fourni à la tâche de fond
• Le type de donnée à transmettre pendant la progression de la tâche
• Le type de donnée renvoyé par la tâche

La méthode doInBackground ( le traitement se fait dans cette méthode ) doit absolument être implémentée.

Les méthodes onPreExecute ( méthode appelée avant le début du traitement ), onProgressUpdate ( appelée durant le traitement ), onPostExecute ( appelée à la fin du traitement ) sont facultatives !

Reprenons donc notre application avec la classe AsyncTask :

public class AsyncTastActivity extends Activity {    /** Called when the activity is first created. */    @Override    public void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.main);    Button btn = (Button) findViewById(R.id.btn);    btn.setOnClickListener(new OnClickListener() {    public void onClick(View v) {    new UseTaskasync().execute();    }    });    }    private class UseTaskasync extends AsyncTask< Void, Void,Void >{         @Override     protected void onPreExecute() {    Toast.makeText(getApplicationContext(), "Début du traitement", Toast.LENGTH_LONG).show();     }      @Override     protected Void doInBackground(Void... params) {     try {     Thread.sleep(10000);     } catch (InterruptedException e) {     }     return null;     }     @Override     protected void onPostExecute(Void l) {     Toast.makeText(getApplicationContext(), "Fin du traitement", Toast.LENGTH_LONG).show();    }     } 

Relancez votre application, il est maintenant possible d’utiliser la zone de saisie tout de suite après le clic sur le bouton ! Ceci prouve bien que le traitement n’est pas réalisé par le thread principal mais par le deuxième créé par la classe AsyncTask.

La classe AsyncTask et ses méthodes permet donc de naviguer dans notre application ( rentrer du texte dans un champ ) tout en éxécutant une tâche au moyen de tâches asyncrones !

Merci d’avoir suivi ce tutoriel ! N’oublie surtout pas de VOTER et de la PARTAGER !!

A la lecture de ce titre, vous vous doutez bien que nous allons aborder plusieurs choses pendant ce tuto :

• Obtention d’une clé pour l’api google places
• Récupération d’un ou plusieurs lieux ( banque, bar … ) dans un périmètre de 500m selon un point donné
• Utilisation de la classe geocoder pour transformer une adresse en une coordonnée
• traitement du résultat renvoyé sous forme de Json

Tout d’abord, afin d’utiliser l’api google places, il nous faut obtenir une clé de service google places, accessible ici :

https://code.google.com/apis/console/b/0/

Dans l’onglet Api access, créez un nouveau compte puis récupérer l’api key.

Dans l’onglet Services, activez « Places API« .

Pour pouvoir récupérer les lieux dans les 500m aux environs d’un point ( latitude/ longitude ), il faut appeler une url de ce type en remplaçant le key par la vôtre :

https://maps.googleapis.com/maps/api/place/search/json?location=48.9344042,2.3535862&radius=500&types=food&sensor=false&key=METTRE ICI VOTRE KEY

A la racine du Json renvoyé se trouve « results« . Il va contenir une liste de lieux, à un lieu est associé des attributs tels que ( id, name … )

Dans le cadre de ce tutoriel, nous allons nous contenter de demander à un utilisateur de rentrer une adresse, de sélectionner un type de lieu puis de les afficher à l’écran.

Créons donc le layout :

<?xml version=« 1.0 » encoding=« utf-8 »?>

<LinearLayout xmlns:android=« http://schemas.android.com/apk/res/android »

  android:orientation=« vertical »

  android:layout_width=« fill_parent »

  android:layout_height=« fill_parent »

  >

    <EditText  android:id=« @+id/addr »

        android:layout_width=« fill_parent »

        android:layout_height=« wrap_content »/>

 <RadioGroup

     android:id=« @+id/rg1 »

  android:layout_width=« fill_parent »

   android:layout_height=« wrap_content »

   android:orientation=« horizontal »>

   <RadioButton

    android:id=« @+id/option1 »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« bank » />

   <RadioButton

    android:id=« @+id/option2 »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« bar » />

   <RadioButton

    android:id=« @+id/option3 »

    android:layout_width=« wrap_content »

    android:layout_height=« wrap_content »

    android:text=« restaurant » />

 </RadioGroup>

 <TextView

android:id=« @+id/maTextView »

android:layout_marginTop=« 25px »

android:layout_width=« wrap_content »

android:layout_height=« wrap_content »

android:gravity=« center »/>

</LinearLayout>

Redéfinition de la méthode OnCreate :

public void onCreate(Bundle savedInstanceState) {

             super.onCreate(savedInstanceState);

             setContentView(R.layout.main);

             RadioGroup rgroup = (RadioGroup) findViewById(R.id.rg1);

       //On écoute un changement d’évènement sur les boutons radio

             rgroup.setOnCheckedChangeListener(new OnCheckedChangeListener() {

                    public void onCheckedChanged(RadioGroup group, int checkedId) {

                           try {

                                  //on créé une instance de geocoder

                                  Geocoder gc = new Geocoder(JsonParsingActivity.this);

                                  EditText adress = (EditText) findViewById(R.id.addr);

                                  List<Address> foundAdresses;

                                  /*On récupère l’adresse saisie par l’utilisateur

                                  Pour ceux qui ont suivi le tuto de géolocalisation,il peut etre intéressant de vérifier

                                  qu’une adresse a été saisie,si ce n’est pas fait alors prendre comme adresse la position actuelle de l’utilisateur

                                  */

                                  String addressInput = adress.getText().toString();

                                  //On récupère une liste d’adresse grace à la classe geocoder

                                  foundAdresses = gc.getFromLocationName(addressInput, 5);

                    //On ne s’interesse qu’à la première adresse de la liste,il est cependant possible d’afficher à l’utilisateur

                                  //une liste déroulante d’adresse possible pour qu’il sélectionne la bonne adresse

                                  Address x = foundAdresses.get(0);

                                 //on récupère la latitude et longitude correspondante à l’adresse

                                  final double lat = x.getLatitude();

                                  final double lng = x.getLongitude();

                    //on récupère le bouton radio sélectionné

                                  RadioButton rb = (RadioButton) findViewById(checkedId);

                                  //on demande à gogole les lieux avoisinantes correspondant au type sélectionné par l’utilisateur

                                  String  places = getPlaces(rb.getText().toString(),lat,lng);

                                  StringBuilder builder = new StringBuilder();

                                  try {

                                         //On parse le Json renvoyé

                                        JSONObject jsonObj = new JSONObject(places);

                                        //l’attribut results est une liste d’objet json donc on le récupère avec getJsonArray

                                        JSONArray results = jsonObj.getJSONArray(« results »);

                                        for (int i = 0; i < results.length(); i++) {  

                                               //Pour chaque jsonObjet du jsonArray results on récupère la valeur de l’attribut name

                                               builder.append(results.getJSONObject(i).getString(« name »).toString()).append(« \n »);

                                        }

                                  } catch (Exception e) {

                                        e.printStackTrace();

                                  }

                                  ((TextView)findViewById(R.id.maTextView)).setText(builder.toString());

                           } catch (IOException e1) {

                                  // TODO Auto-generated catch block

                                  e1.printStackTrace();

                           }

                    }

             });

       }

On effectue maintenant un appel de l’api places de google :

//google limite le nombre de requettes à 1000 tout les 24h pour un api key donné

       public String getPlaces(String type,double lat,double lng) {

             //Url pour la requette

             String url = « https://maps.googleapis.com/maps/api/place/search/json?location= »+lat+ », »+lng+ »&radius=500&types= »+type+ »&sensor=false&key=AIzaSyA5J_JPOa5jtuXaOgbTeHqmNzh61u54hSs »;

             StringBuilder builder = new StringBuilder();

             HttpClient client = new DefaultHttpClient();

             HttpGet httpGet = new HttpGet(url);

             try {

                    HttpResponse response = client.execute(httpGet);

                    StatusLine statusLine = response.getStatusLine();

                    int statusCode = statusLine.getStatusCode();

                    //200 pour dire que la requette s’est bien déroulée

                    if (statusCode == 200) {

                           HttpEntity entity = response.getEntity();

                           InputStream content = entity.getContent();

                           BufferedReader reader = new BufferedReader(

                                        new InputStreamReader(content));

                           String line;

                           while ((line = reader.readLine()) != null) {

                                  builder.append(line);

                           }

                    } else {

                           Log.i(JsonParsingActivity.class.toString(), « Erreur de chargement »);

                    }

             } catch (ClientProtocolException e) {

                    e.printStackTrace();

             } catch (IOException e) {

                    e.printStackTrace();

             }

             return builder.toString();

       }

 Et c’est ainsi que s’achève notre tuto sur la géolocalisation via google places !

Bon code à tous 😀