E-vidence

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- On reste dans le classique -->
    <string name="hello">Hello World, LifeCyleTutorial!</string>
    <string name="app_name">LifeCyleTutorial</string>
    <!-- 
    	Ici on met l'invitation de selection de la liste déroulante.
    	Un backslash permet de d'échapper l'apostrophe, sinon elle
    	ne s'affiche pas.
    -->
	<string name="invite">Choisissez le nombre d\'images</string>
	<!-- Le label du bouton "fermer" -->
	<string name="close">Fermer l\'application</string>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<!-- ressources contient toutes les listes -->
<resources>
	<!-- on peut typer une liste
     ici une liste de chaînes de caractères 
     on lui donne un nom qui permet de la référencer plus tard -->
    <string-array name="number">
        <item>1</item>
        <item>2</item>
        <item>3</item>
        <item>4</item>
        <item>5</item>
    </string-array>
</resources>

<?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"
    >
 
    <!-- 
    	Spinner est le widget de liste déroulante.
    	android:prompt est une référence simple à strings.xml pour le message d'invite.
    	android:entries est une référence à arrays.xml pour « populer » la liste.
    -->
	<Spinner 
	        android:id="@+id/spinner"
	        android:layout_width="fill_parent"
	        android:layout_height="wrap_content"
	        android:prompt="@string/invite"
	        android:entries="@+array/number"
	 />
 
	  <!-- 
    	On rajoute un Layout qui contient les images.
    	Notez le android:layout_height="wrap_content".
    	Si il était en "fill_parent", on ne verrait pas
    	le dernier bouton.
       -->
 
	 <LinearLayout 
	    android:id="@+id/picture_list"
	    android:orientation="vertical"
	    android:layout_width="fill_parent"
	    android:layout_height="wrap_content"
    >
 
		<!-- 
    	On Créé cinq images, dont une seule visible.
    	On pourrait tout aussi bien les mettre dynamiquement dans 
    	onCreate(), ça rendrait le programme plus souple mais 
    	autant ne pas surcharger cet exemple.
    	Notez qu'on ajoute pas d'id, car nous n'en utiliserons pas.
    	Enfin, l'image utilisée est icon, car cette image existe
    	toujours dans tout projet Android nouvellement créé.
       -->
 
		<ImageView 
		  android:src="@drawable/icon"
		  android:layout_width="wrap_content"
		  android:layout_height="wrap_content"/>		
 
		<ImageView 
		  android:src="@drawable/icon"
		  android:layout_width="wrap_content"
		  android:layout_height="wrap_content"/>
 
		<ImageView 
		  android:src="@drawable/icon"
		  android:layout_width="wrap_content"
		  android:layout_height="wrap_content"/>		
 
		<ImageView 
		  android:src="@drawable/icon"
		  android:layout_width="wrap_content"
		  android:layout_height="wrap_content"/>
 
		<ImageView 
		  android:src="@drawable/icon"
		  android:layout_width="wrap_content"
		  android:layout_height="wrap_content"/>		
 
    </LinearLayout>
 
    <!-- 
    	On rajoute un bouton pour fermer l'application.
 
    -->
 
    <Button 
     android:id="@+id/close_button"
	 android:text="@string/close"
	 android:layout_width="fill_parent"
	 android:layout_height="wrap_content"
	/>
 
</LinearLayout>

package net.evidence.LifeCyleTutorial;
 
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.Toast;
import android.widget.AdapterView.OnItemSelectedListener;
 
public class LifeCyleTutorial extends Activity {
 
	Spinner spinner;
	LinearLayout pictures_list;
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
 
    	// TOUJOURS, TOUJOURS, TOUJOURS appeler la méthode du parent
    	// au début d'une méthode du cycle de vie qu'on override
        super.onCreate(savedInstanceState);
 
        // Dans onCreate(), on initialise la vue
        // car on a besoin de le faire une seule fois
        setContentView(R.layout.main);
 
        // On peut aussi initiliser des membres de classe
        // tel que des accès en cache pour les objets View
        // afin d'éviter d'appeler findViewById à chaque
        // fois qu'on a besoin d'eux
 
        // Ici, la liste déroulante
        this.spinner = (Spinner) findViewById(R.id.spinner);
 
        // Là, le conteneur des images
        this.pictures_list = (LinearLayout) findViewById(R.id.picture_list);
 
        // "liste" est un abus de langage car on utilise par vraiment
        // une liste mais un LinearLayout
        // nous verrons les vraies listes dans un autre chapitre
 
        /* Pour finir, on bind une bonne fois pour toute les événements
          de l'application. Le plus souvent on a besoin de le faire
          une seule fois, bien que certaines interfaces avancées
          demandent de le faire à la volée.
 
          On ajoute donc un comportement au changement de valeur
          de la liste déroulante. Ici on va utiliser une classe anonyme
          pour faire vite. Dans un programme propre, et comme expliqué
          dans le chapitre précédent, il vaudrait mieux créer un événement
          personnalisé dans un package "event" dédié.
        */ 
 
        this.spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
 
			@Override
			public void onItemSelected(AdapterView arg0, View arg1,
					int arg2, long arg3) {
 
				// On met ici ce qui arrive quand on change la valeur
				// du spinner. Dans notre cas, rafraichir les images
				// Comme c'est une innerclass, "this" pointe sur
				// OnItemSelectedListener et on doit utiliser la syntaxe
				// barbare vu dans un tuto précédent
				LifeCyleTutorial.this.refreshPicturesList();
 
			}
 
			@Override
			public void onNothingSelected(AdapterView arg0) {
				// OSEF dans notre cas
			}
 
        });
 
        // Pour finir, on lie l'événement au bouton "fermer"
        ((Button) findViewById(R.id.close_button)).setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				// finish est une méthode d'Activity qui ferme
				// l'application
				LifeCyleTutorial.this.finish();
			}
		});
 
        // on met à jour l'interface au moins une fois
        this.refreshPicturesList();
 
        // Bien montrer que l'on est dans onCreate()
        this.popUp("onCreate()");
 
    }
 
    /**
     * Créer un Toast avec un message qui s'affiche immédiatement
     * pour une seconde.
     * On va utiliser ça pour bien visualiser les changements d'états.
     * Vous allez voir que les moments où on passe d'un état à l'autre
     * ne sont pas vraiment instinctifs : en effet votre application
     * se ferme et s'ouvre elle même en parallèle, et les messages
     * semblent mélangés.
     * Essayez de cliquer sur "home", "back", "téléphoner" ou une autre
     *  application pour voir les différents effets.
     *  Vous verrez alors l'interêt de bien remplir toutes les méthodes.
     */
    public void popUp(String message)
    {
    	Toast.makeText(this, message, 1).show();
    }
 
    /**
     * Retourne le nombre d'images à afficher d'après la sélection
     * dans la liste déroulante
     */
    public int getNumberOfPictures()
    {
    	return Integer.parseInt((String) this.spinner.getSelectedItem());
    }
 
    /**
     * Place la liste déroulante sur la valeur selectionnée.
     * Ici on utilise le fait que la valeur du nombre de photos
     * correspond presque à sa position dans le spinner.
     * Dans un vrai programme, on a généralement un système de mapping
     * plus complexe, mais ce n'est pas le but du tuto.
     */
    public void setNumberOfPictures(int number_of_pictures)
    {
    	// -1 car la numérotation du spinner commence à zéro
    	// mais notre array commence à 1
    	this.spinner.setSelection(number_of_pictures - 1);
    }
 
    /**
     * Met à jours la liste des images. On ne va pas créer et retirer
     * des vues à tout bout de champ. On va donc juste les cacher.
     * Bien sûr c'est un exemple académique et pas optimisé. On cherche
     * ici à comprendre comment ça marche, pas à recoder Google Map.
     */
	private void refreshPicturesList() {
 
		/* On récupère le nombre de vues.
		 on sait qu'il y en a 5, mais cette méthode est propre car
		 elle marche dans tous les cas. Si par exemple vous décidez
		 de créér un nombre de ImageView à la volée dans onCreate(),
		 cette méthode marche toujours. */
		int number_of_picture_views = this.pictures_list.getChildCount();
 
		// On récupère le nombres d'image qu'on veut afficher
		int picture_to_display = this.getNumberOfPictures();
 
		// On va utiliser une vue image, mieux vaut l'initialiser hors de la boucle
		ImageView img;
 
		// On met autant d'images que voulu en visible
		for (int i=0; i < picture_to_display; i++ )
		{
			img = (ImageView) this.pictures_list.getChildAt(i);
			img.setVisibility(View.VISIBLE);
		}
 
		// Tout le reste est en invisible
		for (int i=picture_to_display; i < number_of_picture_views; i++ )
		{
			img = (ImageView) this.pictures_list.getChildAt(i);
			img.setVisibility(View.GONE);
		}
 
	}
 
}

package net.evidence.LifeCyleTutorial;
 
// quelques nouveaux imports
import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.Toast;
import android.widget.AdapterView.OnItemSelectedListener;
 
public class LifeCyleTutorial extends Activity {
 
	Spinner spinner;
	LinearLayout pictures_list;
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
 
    	// TOUJOURS, TOUJOURS, TOUJOURS appeler la méthode du parent
    	// au début d'une méthode du cycle de vie qu'on override
        super.onCreate(savedInstanceState);
 
        // Dans onCreate(), on initialise la vue
        // car on a besoin de le faire une seule fois
        setContentView(R.layout.main);
 
        // On peut aussi initiliser des membres de classe
        // tel que des accès en cache pour les objets View
        // afin d'éviter d'appeler findViewById à chaque
        // fois qu'on a besoin d'eux
 
        // Ici, la liste déroulante
        this.spinner = (Spinner) findViewById(R.id.spinner);
 
        // Là, le conteneur des images
        this.pictures_list = (LinearLayout) findViewById(R.id.picture_list);
 
        // "liste" est un abus de langage car on utilise par vraiment
        // une liste mais un LinearLayout
        // nous verrons les vraies listes dans un autre chapitre
 
        /* Pour finir, on bind une bonne fois pour toute les événements
          de l'application. Le plus souvent on a besoin de le faire
          une seule fois, bien que certaines interfaces avancées
          demandent de le faire à la volée.
 
          On ajoute donc un comportement au changement de valeur
          de la liste déroulante. Ici on va utiliser une classe anonyme
          pour faire vite. Dans un programme propre, et comme expliqué
          dans le chapitre précédent, il vaudrait mieux créer un événement
          personnalisé dans un package "event" dédié.
        */ 
 
        this.spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
 
			@Override
			public void onItemSelected(AdapterView arg0, View arg1,
					int arg2, long arg3) {
 
				// On met ici ce qui arrive quand on change la valeur
				// du spinner. Dans notre cas, rafraichir les images
				// Comme c'est une innerclass, "this" pointe sur
				// OnItemSelectedListener et on doit utiliser la syntaxe
				// barbare vu dans un tuto précédent
				LifeCyleTutorial.this.refreshPicturesList();
 
			}
 
			@Override
			public void onNothingSelected(AdapterView arg0) {
				// OSEF dans notre cas
			}
 
        });
 
        // Pour finir, on lie l'événement au bouton "fermer"
        ((Button) findViewById(R.id.close_button)).setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				// finish est une méthode d'Activity qui ferme
				// l'application
				LifeCyleTutorial.this.finish();
			}
		});
 
        // plus de mise à jour de l'interface ici
        // this.refreshPicturesList();
        // on mettra tout dans onResume() qui est appelé
        // à chaque fois
 
        // Bien montrer que l'on est dans onCreate()
        this.popUp("onCreate()");
 
    }
 
    // TOUTE CETTE PARTIE NE CHANGE PAS
 
    /**
     * Créer un Toast avec un message qui s'affiche immédiatement
     * pour une seconde.
     * On va utiliser ça pour bien visualiser les changements d'états.
     * Vous allez voir que les moments où on passe d'un état à l'autre
     * ne sont pas vraiment instinctifs : en effet votre application
     * se ferme et s'ouvre elle même en parallèle, et les messages
     * semblent mélangés.
     * Essayez de cliquer sur "home", "back", "téléphoner" ou une autre
     *  application pour voir les différents effets.
     *  Vous verrez alors l'interêt de bien remplir toutes les méthodes.
     */
    public void popUp(String message)
    {
    	Toast.makeText(this, message, 1).show();
    }
 
    /**
     * Retourne le nombre d'images à afficher d'après la sélection
     * dans la liste déroulante
     */
    public int getNumberOfPictures()
    {
    	return Integer.parseInt((String) this.spinner.getSelectedItem());
    }
 
    /**
     * Place la liste déroulante sur la valeur selectionnée.
     * Ici on utilise le fait que la valeur du nombre de photos
     * correspond presque à sa position dans le spinner.
     * Dans un vrai programme, on a généralement un système de mapping
     * plus complexe, mais ce n'est pas le but du tuto.
     */
    public void setNumberOfPictures(int number_of_pictures)
    {
    	// -1 car la numérotation du spinner commence à zéro
    	// mais notre array commence à 1
    	this.spinner.setSelection(number_of_pictures - 1);
    }
 
    /**
     * Met à jours la liste des images. On ne va pas créer et retirer
     * des vues à tout bout de champ. On va donc juste les cacher.
     * Bien sûr c'est un exemple académique et pas optimisé. On cherche
     * ici à comprendre comment ça marche, pas à recoder Google Map.
     */
	private void refreshPicturesList() {
 
		/* On récupère le nombre de vues.
		 on sait qu'il y en a 5, mais cette méthode est propre car
		 elle marche dans tous les cas. Si par exemple vous décidez
		 de créér un nombre de ImageView à la volée dans onCreate(),
		 cette méthode marche toujours. */
		int number_of_picture_views = this.pictures_list.getChildCount();
 
		// On récupère le nombre d'images qu'on veut afficher
		int picture_to_display = this.getNumberOfPictures();
 
		// On va utiliser une vue image, mieux vaut de l'initialiser hors de la boucle
		ImageView img;
 
		// On met autant d'images que voulu en visible
		for (int i=0; i < picture_to_display; i++ )
		{
			img = (ImageView) this.pictures_list.getChildAt(i);
			img.setVisibility(View.VISIBLE);
		}
 
		// Tout le reste est en invisible
		for (int i=picture_to_display; i < number_of_picture_views; i++ )
		{
			img = (ImageView) this.pictures_list.getChildAt(i);
			img.setVisibility(View.GONE);
		}
 
	}
 
	// A PARTIR DE LA ON MET LES METHODES DU CYCLE DE VIE
        // en général on les met en debut de classe après onCreate()
	// ici c'est pour bien vous montrer l'évolution
 
    @Override
    protected void onStop()
    {
    	// Ai-je préciser de toujours appeler super en premier ?
        super.onStop();
 
        /*
         * Dans onStop(), vous allez très probablement avoir besoin
         * de sauver des états de manière permanente. On peut
         * le faire automatiquement en utilisant le framework des préférences
         * d'Android. Il peut faire de nombreuses choses telles que générer
         * des menus automatiquement, mais nous l'utiliserons pour
         * un usage basique : sauver vos données.
         *
         * Android fournit SharedPreferences, qui agit comme un mapping entre des clés
         * (chaînes de caractères arbitraires de votre choix) et des valeurs.
         * Elles sont sauvegardées de manière permanente, même si vous éteignez votre
         * téléphone. C'est un peu comme si vous utilisiez une base de données
         * avec deux champ, un pour le nom, un pour la valeur. Si ce n'est que
         * tout est fait automatiquement pour vous. Si vous êtes un pythoniste,
         * cela vous rappelera le module shelve.
		 */
 
        // On créé des préférences partagées en leur donnant un nom et des permission
        SharedPreferences settings = getSharedPreferences("my_saved_pref", // on devrait faire une constante pour ça
        													Context.MODE_PRIVATE); // vous seuls pouvez lire les prefs
 
        // Pour modifier des préférence, il faut passer par un objet éditeur
        SharedPreferences.Editor editor = settings.edit();
 
        // On sauve ensuite les valeurs que l'on souhaite en précisant leur type
        // ici on sauve le nombre d'images
        editor.putInt("number_of_picture",  // ça aussi il faudrait le mettre en constante
        			  this.getNumberOfPictures());
 
        // On sauvegarde les modifications
        editor.commit();
 
        // Bien montrer que l'on est dans onStop()
        this.popUp("onStop()");
    }
 
    @Override
    public void onStart()
    {
        super.onStart();
        // Dans onStart(), on fait exactement l'opération inverse
        // de onStop()
 
        // On récupère les préférences partagées
        SharedPreferences settings = getSharedPreferences("my_saved_pref", // on réutilise le nom
        													Context.MODE_PRIVATE); // et le mode
 
        // Récupère l'info qu'on a sauvegardée.
        // Comme on a précisé le type à la sauvegarde
        // on peut récupérer une valeur typée directement
        this.setNumberOfPictures(settings.getInt("number_of_picture",
                								 1)); 
 
        /*
         * Vous aurez noté qu'il y a un deuxième argument. Tous les getters
         * des conteneurs dans Android possèdent cet argument. Il permet de
         * spécifier une valeur à retourner si la clé n'existe pas. C'est
         * TRÈS pratique car cela évite de tester l'existance de la valeur.
         * On peut ainsi récupérer une valeur par défaut si la clé n'a encore
         * jamais été utilisée. Ici, si jamais c'est la première fois que
         * l'on utilise le programme, on a pas encore de nombre de photos
         * enregistré. On retourne donc le nombre par défaut : 1.
         */
 
        // Bien montrer que l'on est dans onStart()
        this.popUp("onStart()");
    }
 
    @Override
    public void onSaveInstanceState(Bundle outState)
    {
    	/*
    	 * On va mettre ici la même chose dans onStop() mais en utilisant
    	 * une méthode différente.
    	 * onSaveInstanceState() est appelée uniquement si Android kill
    	 * brusquement l'application. Dans ce cas le système donne une chance
    	 * à l'application de sauvegarder son état dans un objet de type
    	 * Bundle. Vous aurez l'occasion de revoir Bundle car c'est un objet
    	 * utilisez massivement pour la communication entre processus
    	 * dans Android.
    	 *
    	 * Et oui, ça fait un peu doublon avec onStop(), mais c'est comme ça et puis
    	 * c'est tout.
    	 */
 
        super.onSaveInstanceState(outState);
 
        // Contrairement à l'usage de SharedPreference, l'objet qui va contenir
        // nos données est à usage unique et déjà fourni en paramètre
        // il n'y a donc plus qu'à sauvegarder, en utilisant la même syntaxe
 
        outState.putInt("number_of_picture",
        				this.getNumberOfPictures());
 
        // Bien montrer que l'on est dans onSaveInstanceState()
        this.popUp("onSaveInstanceState()");
    }
 
    @Override
    public void onRestoreInstanceState(Bundle savedInstanceState)
    {
    	/*
    	 * Dans onRestoreInstanceState(), on fait exactement l'inverse de l'opération
    	 * de onSaveInstanceState().
    	 */
        super.onRestoreInstanceState(savedInstanceState);
        this.setNumberOfPictures(savedInstanceState.getInt("number_of_picture",
        // Toujours utiliser la valeur par défaut même si elle est facultative !
        													1)); 
 
        // Bien montrer que l'on est dans onRestoreInstanceState()
        this.popUp("onRestoreInstanceState()");
    }
 
    @Override
    protected void onPause()
    {
        super.onPause();
        /* Normalement ici on met le traitement des connections.
         * Dans cette application simple, on a rien de tout cela donc
         * la méthode est vide.
         *
         * Généralement ça donne un code du style :
         *
         * this.db_helper.close();
         * this.sensor_listener.pause();
         */
 
        // Bien montrer que l'on est dans onPause()
        this.popUp("onPause()");
    }
 
    @Override
    protected void onResume()
    {
        super.onResume();
        /* Idem, on met l'inverse de onPause().
         * Dans cette application simple, on a pas
         * de connexion mais généralement ça donne un code du style :
         *
         * this.db_helper.open();
         * this.sensor_listener.resume();
         *
         * On place aussi ici une méthode qui rafraichit l'affichage.
         * En effet l'affichage est celui par défaut, dans onCreate().
         * Mais si on restore un état, il faut mettre à jour ce que
         * l'utilisateur voit pour qu'il se retrouve visuellement là où
         * il était. Sinon on fait tout ça pour rien :-)
         */
 
        this.refreshPicturesList();
 
        // Bien montrer que l'on est dans onResume()
        this.popUp("onResume()");
    }
 
}