Tout d’abord qu’est-ce qu’un contrôle personnalisé ? (Custom control ou encore Custom component).

Hé bien un c’est un composant que nous allons utiliser dans notre application pour afficher une donnée, nous allons développer un contrôle personnalisé car soit ce composant n’existe pas dans le SDK Android, soit parce que cet élément est redondant dans toute l’interface.

Le cas où le composant n’existe pas

• Diagramme (camembert,bâton,etc…)
• Compteur de vitesse
• Thermomètre
• Etc…

Cas où le composant existe mais on le modifie pour le réutiliser tout le temps

• Chargement d’une image
• Bannière publicitaire
• Menu
• etc…

Héritage !

L’héritage est très important dans la création d’un contrôle.

Les contrôles se différencies avec deux grands types

1. Affichage à base de canvas (View)
2. Affichage à base d’OpenGL (SurfaceView)

Chargement d’une image asynchrone

Imaginons que nous avons une ListView avec des images à charger, pour rendre notre application performante nous allons utiliser un thread pour charger nos images sinon on risque de bloquer l’utilisateur si la vitesse de téléchargement est trop lente.

Donc il nous faut 1 ImageView et 1 Thread à chaque fois, mais c’est embêtant j’ai 2 activités qui utilises le même fonctionnement, voir même plusieurs applications !

Pas d’inquiétudes matelot nous allons faire un contrôle pour cela

Tout d’abord on va partir d’un contrôle existant (ImageView) puis embarquer un Thread dans ce contrôle pour gérer le chargement en asynchrone (AsyncTrask).

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.util.AttributeSet;
import android.widget.ImageView;

/***
 * ImageLoader
 *
 * @author ace
 *
 */
public class ImageLoaderView extends ImageView {

	/**
	 * Constructeur hérité
	 *
	 * @param context
	 * @param attrs
	 */
	public ImageLoaderView(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	public void loadImage(String url) {
		new DownloadImage(this).execute(url);
	}

	private class DownloadImage extends AsyncTask {

		final ImageView imageView;

		public DownloadImage(ImageView imageView) {
			this.imageView = imageView;
		}

		@Override
		protected Bitmap doInBackground(String... params) {
			if (params.length == 0)
				return null;

			try {
				URL url = new URL(params[0]);
				InputStream stream = url.openStream();

				Bitmap bf = BitmapFactory.decodeStream(stream);

				return bf;

			} catch (MalformedURLException e) {
				return null;
			} catch (IOException e) {
				return null;
			}
		}

		@Override
		protected void onPostExecute(Bitmap result) {
			if(result != null)
				imageView.setImageBitmap(result);

			super.onPostExecute(result);
		}

	}

}

Je vous donne la classe directement, pas besoin d’explication vous savez déjà charger une image (Partie 8) et vous connaissez aussi les threads (Partie 9).

Nous allons maintenant utiliser notre nouveau composant dans notre layout principal

<?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" >

<com.aceart.formation.component.ImageLoaderView
android:id="@+id/imageLoader1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>

<com.aceart.formation.component.ImageLoaderView
android:id="@+id/imageLoader2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>

<com.aceart.formation.component.ImageLoaderView
android:id="@+id/imageLoader3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>

</LinearLayout>

Trois images loader avec chacun un ID.
Dirigeons nous maintenant vers notre activité

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

        final ImageLoaderView imgL1 = (ImageLoaderView) findViewById(R.id.imageLoader1);
        imgL1.loadImage("http://www.laptopspirit.fr/wp-content/uploads/new/mandriva-logo.thumbnail.jpg");

        final ImageLoaderView imgL2 = (ImageLoaderView) findViewById(R.id.imageLoader2);
        imgL2.loadImage("http://i73.photobucket.com/albums/i240/jazzk1/android-logo-mask.png");

        final ImageLoaderView imgL3 = (ImageLoaderView) findViewById(R.id.imageLoader3);
        imgL3.loadImage("http://upload.wikimedia.org/wikipedia/fr/7/78/Quakelive_logo_300.png");

    }

On récupère nos ImageLoader et on effectue l’action de chargement.
Lancer l’application et miracle le chargement est en asynchrone et pas besoin de réécrire le code et qui plus est vous pouvez réutiliser ce code dans les ListView etc…

Création d’un graphique

Nous allons maintenant voir comment créer un custom components grâce au canvas.

Les étapes :

1. Définir le modèle de données (Classe Item)
2. Créer le contrôle (Héritage de la classe View)
3. Implémenter la méthode onDraw
4. Dessiner le diagramme grâce au canvas
5. Afficher

Rien de plus simple en fait.

Voici la classe item que nous utiliserons pour fournir en données notre vue

public class PieChartItem {
	private double value;
	private int color;

	public PieChartItem(double value, int color) {
		this.value = value;
		this.color = color;
	}
	public double getValue() {
		return value;
	}
	public void setValue(double value) {
		this.value = value;
	}
	public int getColor() {
		return color;
	}
	public void setColor(int color) {
		this.color = color;
	}
}

Notre objet contient une valeur et une couleur.

Notre vue maintenant

public class PieChartView extends View {

	private List<PieChartItem> items;

	public PieChartView(Context context, AttributeSet attrs) {
		super(context, attrs);
		items = new ArrayList&lt;PieChartItem&gt;();
	}

	@Override
	protected void onDraw(Canvas canvas) {
		drawChart(canvas);
		super.onDraw(canvas);
	}

	private void drawChart(Canvas canvas) {
		if (items != null) {
		}
	}
}

On a bien hérité de la vue, on a le bon constructeur et la méthode onDraw est implémentée
Il reste plus qu’a appeler notre petit diagramme dans le layout

<?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">

<com.aceart.formation.component.PieChartView
 android:id="@+id/pieChart"
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:background="@android:color/white" />

</LinearLayout>

Je vous donnes le code d’exemple tout de même pour pouvoir vous amusez

Classe complète:

public class PieChartView extends View {

	private List<PieChartItem> items;

	public PieChartView(Context context, AttributeSet attrs) {
		super(context, attrs);
		items = new ArrayList&lt;PieChartItem&gt;();
	}

	@Override
	protected void onDraw(Canvas canvas) {
		drawChart(canvas);
		super.onDraw(canvas);
	}

	private void drawChart(Canvas canvas) {
		if (items != null) {

			// angle de départ
			float angleDepart = 0.f;
			double somme = getSomme();

			// Zone carrée
			RectF zoneDessin = new RectF(0, 0, getWidth(), getWidth());

			// Pinceau
			Paint paint = new Paint();
			paint.setAntiAlias(true);
			paint.setStyle(Paint.Style.FILL);

			// On passe chaque item en revue
			for (PieChartItem item : items) {

				// on change la couleur
				paint.setColor(item.getColor());

				// On calcul l'angle d'ouverutre
				float sweepAngle = (float) ((item.getValue() / somme) * 360);

				// On dessine l'arc
				canvas.drawArc(zoneDessin, angleDepart, sweepAngle, true, paint);

				// On change l'angle de départ
				angleDepart += sweepAngle;
			}
		}
	}

	private double getSomme() {
		double somme = 0;

		for (PieChartItem item : items) {
			somme += item.getValue();
		}

		return somme;
	}

	public void addValue(PieChartItem item) {
		this.items.add(item);
	}

	public void setValues(List&lt;PieChartItem&gt; items) {
		this.items = items;
	}

}

Les appels dans l’activité principale :

public class FormationCustomComponentActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        final PieChartView pieChartView = (PieChartView) findViewById(R.id.pieChart);

        pieChartView.addValue(new PieChartItem(25, Color.GREEN));
        pieChartView.addValue(new PieChartItem(75, Color.RED));

    }
}

Et le rendu pour finir

Maintenant à vous de vous amuser à créer vos propres composants.

Bonjour à tous,

Aujourd’hui nous allons aborder un petit outil sympathique embarqué au sein de la plateforme Android, cet outil se nomme le StrictMode.

http://developer.android.com/reference/android/os/StrictMode.html

Vous allez me dire, “c’est quoi cette bête ?” le StrictMode est une mode Strict (ouha !) il permet de rendre son application plus performantes en vous donnant des informations précises.

Les informations peuvent être de plusieurs types

• OS
• Ecriture sur le disque
• Lecture sur le disque
• Opération sur le réseau
• Accès lents
• VM (Machine virtuelle)
• Fuite mémoire sur les activités
• Fuite mémoire sur les objets
• Fuite mémoire sur les données SQL

Ces points sont très importants, car pour faire une bonne application il faut la rendre performante, vous allez me dire qu’aujourd’hui on a 1go de ram, des processeurs dual core etc…

Je ne suis pas d’accord sur ce point, sur l’OS vous n’êtes pas la seule application, l’utilisateurs n’utilise pas forcément de gestionnaire de tâches pour décharger les applications qui ne lui servent plus, tout cela à un impact.

Il faut garder en tête qu’un utilisateur lambda installe des applications et les utilisent fréquemment, de plus ces applications sont peut-être mal codées ce qui pose le problème sur la mémoire encombrées.

Pensez aussi au téléphone de l’ancienne génération avec des petits processeurs et peu de mémoire vive.

Avoir une application optimisée et propre va vous permettre de mieux coder et de rendre son utilisation de meilleure qualité.

Pré-requis

•  Android 2.3 et supérieur

Implémentation

L’implémentation au sein du framework Android n’est disponible qu’à partir d’Android 2.3 donc ne cherchez pas si ça ne fonctionne pas pour les versions inférieures.

Tout d’abord, le StrictMode s’applique uniquement dans les méthodes onCreate(), donc les classes de type Activity, Application et tout autre objet ayant une méthode onCreate.

L’ensemble des informations que nous allons avoir besoin se trouve dans la classe StrictMode fournie par Google.

Au niveau OS nous utiliserons la méthode suivante

public static void setThreadPolicy (StrictMode.ThreadPolicy policy)

Au niveau de la VM nous utiliserons la méthode suivante

public static void setVmPolicy (StrictMode.VmPolicy policy)

Voici un exemple pour la détection au niveau OS

    	StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
    	.detectAll() 	// On détecte tout
    	.penaltyDialog()   // On retourne les informations dans les logs
    	.build());

Au commence par détecter toutes les formes de violations, on affiche les violations dans une popup.

Types de violation (Doc Google)

detectAll() – Detect everything that’s potentially suspect.
detectCustomSlowCalls() – Enable detection of disk reads.
detectDiskReads() – Enable detection of disk reads.
detectDiskWrites() – Enable detection of disk writes.

Retour sur les violations (Doc Google)

penaltyDeath() – Crash the whole process on violation.
penaltyDeathOnNetwork() – Crash the whole process on any network usage.
penaltyDialog()- Show an annoying dialog to the developer on detected violations, rate-limited to be only a little annoying.
penaltyDropBox() – Enable detected violations log a stacktrace and timing data to the DropBox on policy violation.
penaltyFlashScreen() – Flash the screen during a violation.
penaltyLog() – Log detected violations to the system log.

Voici un exemple pour la détection au niveau del a VM

    	StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
    	.detectAll()  // On détecte tout
    	.penaltyLog() // On retourne les informations dans les logs
    	.build());

Au commence par détecter toutes les formes de violations, on affiche les violations dans une popup.

Types de violation (Doc Google)

detectAll() – Detect everything that’s potentially suspect.
detectActivityLeaks() – Detect leaks of Activity subclasses.
detectLeakedClosableObjects() – Detect when an Closeable or other object with a explict termination method is finalized without having been closed.
detectLeakedSqlLiteObjects() – Detect when an SQLiteCursor or other SQLite object is finalized without having been closed.

Retour sur les violations (Doc Google)

penaltyDeath() – Crash the whole process on violation.
penaltyDropBox() – Enable detected violations log a stacktrace and timing data to the DropBox on policy violation.
penaltyLog() – Log detected violations to the system log.

Voici ce que vous pouvez avoir si vous souhaitez accéder a internet sans internet.

Je vous conseil vivement d’utiliser ce petit outils dans vos applications pour améliorer celles-ci.

On y retrouve des exemples,des news, des tutoriaux sur le monde du dotnet et Silverlight.

Je vous invites à le consulter de toute urgence si vous êtes désireux d’explorer cette voie.

Stéphane Louge est l’éditeur de ce blog et je le remercie pour le travail qu’il accomplit.

http://slouge.wordpress.com/

Pour un développeur lambda il est très difficile de comprendre le fonctionnement pour recréer une console, certaines demandant de simuler que quelques Mhz voir Hz de processeur pour faire fonctionner correctement un l’émulateur.

Maintenant c’est chose faites ! BestCoder du site du zéro a écrit un très bon article la dessus, pas à pas il vous aidera a créer votre premier émulateur pour RCA.

Je vous conseilles d’aller faire un tour ici, vous n’en serez que plus ravis.

http://www.siteduzero.com/tutoriel-3-555021-l-emulation-console.html

Ps : Ne vous jetez pas sur l’émulation des consoles NextGen ou GB / GameGear etc… l’approche est beaucoup plus difficile qu’il n’y paraît

Nous allons aborder aujourd’hui la conception d’une application reposant sur les bases de données.

Les bases de données sont un moyen de stocker une donnée dans un format que vous aurez choisi, le stockage est de façon permanent.

Vous pouvez aussi stocker les données au format Xml, texte, json etc…

Ce tutoriel portera uniquement sur le stockage avec le langage SQL voir la Définition SQL.

Android propose utilise le moteur SQL nommé SQLite voir sa Définition.

Le moteur SQLite accepte les types suivants de données

Le type boolean n’est qu’un entier ayant pour valeur 0 et 1

Pour les dates il y a plusieurs manières de procéder

• Dans un champ TEXT : Format YYYY-MM-DD HH:MM:SS.SSS
• Dans un champ REAL : Nombre de jour depuis Greenwich le 24 Novembre 4714 avant J.C
• Dans un champ INTEGER : Nombre de seconde depuis le 01/01/1970 soit la date au format UNIX

Ne vous inquiétez pas SQLite possède des fonctions pour manipuler les dates.

Définition du projet

Nous allons créer une application pour faire nos courses, ça nous permettra d’avoir un contexte de compréhension.

Tout d’abord, il faut penser au format des données.

Dans notre cas une course sera :

• Un produit
• Une quantité
• Un flag acheté (pour suivre notre avancement dans le magasin)

Nous devrons pouvoir Ajouter / Supprimer / Modifier un produit, ainsi que lister les produits.

Nous avons désormais notre contexte pour travailler, il faut maintenant coder tout cela.

Commençons par créer notre objet Course

public class Course {

	private int id;
	private String produit;
	private int quantite;
	private boolean achete;

	public Course(String produit, int quantite) {
		this.produit = produit;
		this.quantite = quantite;
		this.achete = false;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getProduit() {
		return produit;
	}
	public void setProduit(String produit) {
		this.produit = produit;
	}
	public int getQuantite() {
		return quantite;
	}
	public void setQuantite(int quantite) {
		this.quantite = quantite;
	}
	public boolean isAchete() {
		return achete;
	}
	public void setAchete(boolean achete) {
		this.achete = achete;
	}

}

Abordons maintenant l’utilisation des bases de données.

SQLiteOpenHelper

Le but de cette classe est de permettre la création et l’utilisation des bases de données au sein de l’écosystème Android.

Commençons tout d’abord par créer une classe nommée CourseOpenHelper héritant de la classe SQLiteOpenHelper.

Puis nous allons rajouter des attributs statiques à notre classe

	// Version de la base de données
	private static final int DATABASE_VERSION = 1;

	// Nom de la base
	private static final String COURSE_BASE_NAME = "course.db";

	// Nom de la table
	public static final String COURSE_TABLE_NAME = "Course";

	// Description des colonnes
	public static final String COLUMN_ID = "ID";
	public static final int NUM_COLUMN_ID = 0;
	public static final String COLUMN_PRODUIT = "PRODUIT";
	public static final int NUM_COLUMN_PRODUIT = 1;
	public static final String COLUMN_QUANTITE = "QUANTITE";
	public static final int NUM_COLUMN_QUANTITE = 2;
	public static final String COLUMN_ACHETE = "ACHETE";
	public static final int NUM_COLUMN_ACHETE = 3;

	// Requête SQL pour la création da la base
	private static final String REQUETE_CREATION_BDD = "CREATE TABLE "
			+ COURSE_TABLE_NAME + " (" + COLUMN_ID
			+ " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_PRODUIT
			+ " TEXT NOT NULL, " + COLUMN_QUANTITE + " INTEGER NOT NULL, "
			+ COLUMN_ACHETE + " INTEGER NOT NULL);";

Nous avons donc :

• Version de la base de données (pour les mises à jour)
• Nom de la base (nom du fichier)
• Nom de la table (Course pour nous)
• Description des colonnes, ainsi que leur position (0..n)
• La requête de création de la base

	public CourseOpenHelper(Context context, CursorFactory factory) {
		super(context, COURSE_BASE_NAME, factory, DATABASE_VERSION);
	}

	/**
	 * Création de la base
	 */
	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL(REQUETE_CREATION_BDD);
	}

	/**
	 * Mise à jour de la base
	 */
	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		// Lorsque l'on change le numéro de version de la base on supprime la
		// table puis on la recrée
		if (newVersion > DATABASE_VERSION) {
			db.execSQL("DROP TABLE " + COURSE_TABLE_NAME + ";");
			onCreate(db);
		}
	}

Notre méthode onCreate sera appelée si la base n’existe pas, la méthode onUpgrade sera appelée si une mise à jour est à faire.

J’espère que vous suivez toujours  

Repository

Vous en avez peut être déjà entendu parler, en français c’est un dépôt. Il sert à faire la jonction avec notre base de données.

Comme ça en cas d’évolution on n’impacte pas la vue (layout) si ce n’est qu’un correctif ou une modification de la façon d’allez chercher nos données, c’est tout de même plus propre et je vous le conseil fortement.

Créons pour commencer une interface nommée IRepository qui sera générique (gné ?) voir ce tutoriel 

public interface IRepository {

	public List GetAll();
	public T GetById(int id);

	public void Save(T entite);
	public void Update(T entite);
	public void Delete(int id);

	public List ConvertCursorToListObject(Cursor c);
	public T ConvertCursorToObject(Cursor c);
	public T ConvertCursorToOneObject(Cursor c);
}

Alors nos méthodes :

• GetAll : Retourne la liste des données
• GetById : Retourne un objet unique
• Save : Enregistre un objet
• Update : Met à jour un objet
• Delete : Supprime un objet
• ConvertCursorToListObject : Converti un curseur en une liste d’objet
• ConvertCursorToObject : Converti un curseur en un objet
• ConvertCursorToOneObject : Converti un curseur en un seul objet

public abstract class Repository implements IRepository {
	// Base de données
	protected SQLiteDatabase maBDD;

	protected SQLiteOpenHelper sqLiteOpenHelper;

	/**
	 * Constructeur par défaut
	 */
	public Repository() {

	}

	/**
	 * Ouverture de la connection
	 */
	public void Open() {
		maBDD = sqLiteOpenHelper.getWritableDatabase();
	}

	/**
	 * Fermeture de la connection
	 */
	public void Close() {
		maBDD.close();
	}
}

Cette classe comprend deux méthodes et deux attributs.

Attributs :

• maBDD : Relation avec la base de données SQLite
• sqLiteOpenHelper : Notre helper pour traiter avec la base

public class CourseRepository extends Repository {

	public CourseRepository(Context context) {
		sqLiteOpenHelper = new CourseOpenHelper(context, null);
	}

	/**
	 * Suppression d'un produit
	 *
	 * @param id
	 */
	public void DeleteProduit(int id) {
		maBDD.delete(CourseOpenHelper.COURSE_TABLE_NAME,
				CourseOpenHelper.COLUMN_ID + "=?",
				new String[] { String.valueOf(id) });
	}

	/**
	 * Récupération de la liste de tous les produits
	 */
	@Override
	public List GetAll() {
		// Récupération de la liste des courses
		Cursor cursor = maBDD.query(CourseOpenHelper.COURSE_TABLE_NAME,
				new String[] { CourseOpenHelper.COLUMN_ID,
						CourseOpenHelper.COLUMN_PRODUIT,
						CourseOpenHelper.COLUMN_QUANTITE,
						CourseOpenHelper.COLUMN_ACHETE }, null, null, null,
				null, null);

		return ConvertCursorToListObject(cursor);
	}

	/**
	 * Retourne un seul produit
	 */
	@Override
	public Course GetById(int id) {
		Cursor cursor = maBDD.query(CourseOpenHelper.COURSE_TABLE_NAME,
				new String[] { CourseOpenHelper.COLUMN_ID,
						CourseOpenHelper.COLUMN_PRODUIT,
						CourseOpenHelper.COLUMN_QUANTITE,
						CourseOpenHelper.COLUMN_ACHETE },
				CourseOpenHelper.COLUMN_ID + "=?",
				new String[] { String.valueOf(id) }, null, null, null);

		return ConvertCursorToObject(cursor);
	}

	/**
	 * Enregistre en produit dans la base
	 */
	@Override
	public void Save(Course entite) {
		ContentValues contentValues = new ContentValues();
		contentValues.put(CourseOpenHelper.COLUMN_PRODUIT, entite.getProduit());
		contentValues.put(CourseOpenHelper.COLUMN_QUANTITE,
				entite.getQuantite());
		contentValues.put(CourseOpenHelper.COLUMN_ACHETE, entite.isAchete());

		maBDD.insert(CourseOpenHelper.COURSE_TABLE_NAME, null, contentValues);
	}

	/**
	 * Met à jour un produit
	 */
	@Override
	public void Update(Course entite) {
		ContentValues contentValues = new ContentValues();
		contentValues.put(CourseOpenHelper.COLUMN_PRODUIT, entite.getProduit());
		contentValues.put(CourseOpenHelper.COLUMN_QUANTITE,
				entite.getQuantite());
		contentValues.put(CourseOpenHelper.COLUMN_ACHETE, entite.isAchete());

		maBDD.update(CourseOpenHelper.COURSE_TABLE_NAME, contentValues,
				CourseOpenHelper.COLUMN_ID + "=?",
				new String[] { String.valueOf(entite.getId()) });
	}

	/**
	 * Supprime un produit
	 */
	@Override
	public void Delete(int id) {
		maBDD.delete(CourseOpenHelper.COURSE_TABLE_NAME,
				CourseOpenHelper.COLUMN_ID + "=?",
				new String[] { String.valueOf(id) });
	}

	/**
	 * Converti un curseur en une liste de produits
	 */
	@Override
	public List ConvertCursorToListObject(Cursor c) {
		List liste = new ArrayList();

		// Si la liste est vide
		if (c.getCount() == 0)
			return liste;

		// position sur le premeir item
		c.moveToFirst();

		// Pour chaque item
		do {

			Course course = ConvertCursorToObject(c);

			liste.add(course);
		} while (c.moveToNext());

		// Fermeture du curseur
		c.close();

		return liste;
	}

	/**
	 * Méthode utilisée par ConvertCursorToObject et ConvertCursorToListObject
	 */
	@Override
	public Course ConvertCursorToObject(Cursor c) {

		Course course = new Course(
				c.getString(CourseOpenHelper.NUM_COLUMN_PRODUIT),
				c.getInt(CourseOpenHelper.NUM_COLUMN_QUANTITE));
		course.setId(c.getInt(CourseOpenHelper.NUM_COLUMN_ID));
		course.setAchete((c.getInt(CourseOpenHelper.NUM_COLUMN_ACHETE) != 0));

		return course;
	}

	/**
	 * Converti un curseur en un produit
	 */
	@Override
	public Course ConvertCursorToOneObject(Cursor c) {
		c.moveToFirst();

		Course course = ConvertCursorToObject(c);

		c.close();
		return course;
	}
}

Oulala c’est du lourd !

Pour mieux comprendre, toutes actions effectuées de type Get en base (retour d’un ou plusieurs objets) retourne un curseur.

Ce curseur comprend l’intégralité de ce que vous avez demandé, il faut juste passer sur chaque ligne retournée pour l’affectée à un objet, dans notre cas un objet Course.

Pour faire un Save, Delete, Update, GetAll ou encore GetById on utilise simplement une commande fournie par Android.

• GetAll / GetById : Query (String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy)
• Save : Insert (String table, String nullColumnHack, ContentValues values)
• Update : Update (String table, ContentValues values, String whereClause, String[] whereArgs)
• Delete : Delete (String table, String whereClause, String[] whereArgs)

Dans le cas d’un Save,Delete,Update nous utiliserons un objet ContentValues qui transportera nos données.

Enfin de compte il n’y a rien de plus simple !

N’oubliez pas de refermer vos curseurs après utilisations (c’est comme les BIC , sinon ça sèche).

De plus n’oubliez pas d’ouvrir votre connexion avec la base avant un traitement et de la refermée ensuite.

Exemple :

public void DeleteItem(int id) {
	courseRepository.Open();
	courseRepository.Delete(id);
	courseRepository.Close();
}

Je n’expliquerais pas le programme au complet, car la suite ce n’est qu’une Listview, un menu et des boutons (déjà vu dans les autres chapitres).

Mais voici ce que vous devriez avoir à la fin 

Source : Sources de la formation

Ce tutoriel s’inscrit dans la lignée du billet suivante : ListView

Pré requis :

• Projet Android 1.6+
• Avoir lu le tutoriel sur les listview

Nous allons débuter ce cours par une approche simple du fonctionnement des ExpandableListView

Voici notre modèle logique, un Groupe peut contenir 1:n enfants.

De ce fait nous allons commencer par créer nos objets de la même manière

package com.formation.Testexpandable;

import java.util.ArrayList;

public class Groupe {
	private String nom;
	private ArrayList<Objet> objets;

	public Groupe(String nom) {
		super();
		this.nom = nom;
		this.objets = new ArrayList<Objet>();
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public ArrayList<Objet> getObjets() {
		return objets;
	}

	public void setObjets(ArrayList<Objet> objets) {
		this.objets = objets;
	}

}

Nous avons notre classe Groupe qui contiendra une liste d’enfant (objet), ainsi qu’un nom.

package com.formation.Testexpandable;

public class Objet {

	private Groupe groupe;
	private String nom;

	public Objet(Groupe groupe, String nom) {
		super();
		this.groupe = groupe;
		this.nom = nom;
	}

	public Groupe getGroupe() {
		return groupe;
	}

	public void setGroupe(Groupe groupe) {
		this.groupe = groupe;
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

}

Notre classe enfant (objet) contenue dans le groupe, elle contient un nom et est affilée à un groupe.

Nous allons remplir nos objets en vue de les afficher.

package com.formation.Testexpandable;

import java.util.ArrayList;

import android.app.Activity;
import android.os.Bundle;
import android.widget.ExpandableListView;

public class TestexpandableActivity extends Activity {

	private ExpandableListView expandableList = null;

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

		expandableList = (ExpandableListView) findViewById(R.id.expandableView);

		ArrayList<Groupe> groupes = new ArrayList<Groupe>();

		for (int i = 1; i < 10; i++) {

			Groupe groupe = new Groupe("Groupe " + i);

			ArrayList<Objet> donnees = new ArrayList<Objet>();

			for (int x = 1; x < 10; x++) {
				donnees.add(new Objet(groupe, "Objet " + x));
			}

			groupe.setObjets(donnees);

			groupes.add(groupe);
		}
	}
}

Continuons en créant nos layout

Main.xml

<?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">

	<ExpandableListView android:id="@+id/expandableView" android:layout_width="match_parent" android:layout_height="match_parent" >
	</ExpandableListView>
</LinearLayout>

Notre entête pour les groupes

<?xml version="1.0" encoding="utf-8"?>

<TextView xmlns:android="http://schemas.android.com/apk/res/android"
	android:id="@+id/TVGroup"
	android:text="Groupe"
	android:layout_width="match_parent"
	android:layout_height="?android:attr/listPreferredItemHeight"
	android:gravity="center_vertical"
	android:paddingLeft="?android:attr/expandableListPreferredItemPaddingLeft"
	android:textAppearance="?android:attr/textAppearanceLarge"/>

Puis nos enfants

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="horizontal"
  android:layout_width="match_parent"
  android:layout_height="wrap_content">

    <Button android:id="@+id/BTChild" android:text="1" android:layout_width="wrap_content" android:layout_height="wrap_content"/>

    <TextView android:id="@+id/TVChild" android:text="test" android:layout_width="match_parent" android:layout_height="wrap_content"/>

</LinearLayout>

Pour terminer nous allons créer un adapteur pour gérer notre liste.
Pour cela nous allons hériter de la classe BaseExpandableListAdapter.

package com.formation.Testexpandable;

import java.util.ArrayList;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

public class ELVAdapter extends BaseExpandableListAdapter {

	private Context context;
	private ArrayList<Groupe> groupes;
	private LayoutInflater inflater;

	public ELVAdapter(Context context, ArrayList<Groupe> groupes) {
		this.context = context;
		this.groupes = groupes;
		inflater = LayoutInflater.from(context);
	}

	@Override
	public boolean areAllItemsEnabled() {
		return true;
	}

	public Object getChild(int gPosition, int cPosition) {
		return groupes.get(gPosition).getObjets().get(cPosition);
	}

	public long getChildId(int gPosition, int cPosition) {
		return cPosition;
	}

	public View getChildView(int groupPosition, int childPosition, boolean isLastChild, View convertView, ViewGroup parent) {
		final Objet objet = (Objet) getChild(groupPosition, childPosition);

		ChildViewHolder childViewHolder;

        if (convertView == null) {
        	childViewHolder = new ChildViewHolder();

            convertView = inflater.inflate(R.layout.group_child, null);

            childViewHolder.textViewChild = (TextView) convertView.findViewById(R.id.TVChild);
            childViewHolder.buttonChild = (Button) convertView.findViewById(R.id.BTChild);

            convertView.setTag(childViewHolder);
        } else {
        	childViewHolder = (ChildViewHolder) convertView.getTag();
        }

        childViewHolder.textViewChild.setText(objet.getNom());

        childViewHolder.buttonChild.setText(objet.getNom());

        childViewHolder.buttonChild.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				Toast.makeText(context, "Groupe : " + objet.getGroupe().getNom() + " - Bouton : " + objet.getNom(), Toast.LENGTH_SHORT).show();
			}
		});

        return convertView;
	}

	public int getChildrenCount(int gPosition) {
		return groupes.get(gPosition).getObjets().size();
	}

	public Object getGroup(int gPosition) {
		return groupes.get(gPosition);
	}

	public int getGroupCount() {
		return groupes.size();
	}

	public long getGroupId(int gPosition) {
		return gPosition;
	}

	public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) {
		GroupViewHolder gholder;

		Groupe group = (Groupe) getGroup(groupPosition);

        if (convertView == null) {
        	gholder = new GroupViewHolder();

        	convertView = inflater.inflate(R.layout.group_row, null);

        	gholder.textViewGroup = (TextView) convertView.findViewById(R.id.TVGroup);

        	convertView.setTag(gholder);
        } else {
        	gholder = (GroupViewHolder) convertView.getTag();
        }

        gholder.textViewGroup.setText(group.getNom());

        return convertView;
	}

	public boolean hasStableIds() {
		return true;
	}

	public boolean isChildSelectable(int arg0, int arg1) {
		return true;
	}

	class GroupViewHolder {
		public TextView textViewGroup;
	}

	class ChildViewHolder {
		public TextView textViewChild;
		public Button buttonChild;
	}

}

Les parties les plus importantes sont getChildView et getGroupView, ces deux méthodes permettent de d’attacher nos layout a un groupe ou a un objet enfant.

Ne pas oublier le viewHolder, qui permettent d’avoir de meilleur performances.

Et pour finir notre activité

package com.formation.Testexpandable;

import java.util.ArrayList;

import android.app.Activity;
import android.os.Bundle;
import android.widget.ExpandableListView;

public class TestexpandableActivity extends Activity {

	private ExpandableListView expandableList = null;

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

		expandableList = (ExpandableListView) findViewById(R.id.expandableView);

		ArrayList<Groupe> groupes = new ArrayList<Groupe>();

		for (int i = 1; i < 10; i++) {

			Groupe groupe = new Groupe("Groupe " + i);

			ArrayList<Objet> donnees = new ArrayList<Objet>();

			for (int x = 1; x < 10; x++) {
				donnees.add(new Objet(groupe, "Objet " + x));
			}

			groupe.setObjets(donnees);

			groupes.add(groupe);
		}

		ELVAdapter adapter = new ELVAdapter(this, groupes);

		expandableList.setAdapter(adapter);
	}
}

Voilà vous savez désormais utiliser une ExpandableListView.
Si vous avez suivis le tutoriel sur les ListView, il n’y a pas grand changement.

Vous devriez avoir ceci maintenant

Source de la formation :Sources de la formation

Je tenais à vous remercier (oui vous cher visiteur), pour cette année passée ensemble, on ne s’arrête pas la pour autant, mais je tenais à tous vous remercier de venir si nombreux pour consulter le fruit de mon travail (qui vous est dédié bien entendue).

Quelques statistiques sur l’année :

• 60 487 visites
• 122 193 pages vues

• Firefox – 31 561
• Chrome – 20 174
• IE – 4 580
• Opera – 2 078
• Safari – 1 849

Top 3 OS

• Windows – 49 472
• Linux – 7 103
• Mac OS – 3 829

Quelle diversité !

Dans tous les cas Merci à tous et je vous dis à bientôt pour de nouveaux tutoriaux 

 Pré requis :

• Projet Android 2.2
• Un téléphone / tablette
• Un / plusieurs réseaux wifi
• Avoir lu le tutoriel sur les listview

 Permissions :

Notre projet nécessite quelques permissions

• android.permission.ACCESS_WIFI_STATE
• android.permission.CHANGE_WIFI_STATE

La première sert à checker l’état du wifi, la seconde à changer celui-ci

Ressources :

Je vous donnes directement les ressources nécessaires pour l’adapter sans les expliquer, c’est pour ça qu’il faut se référencer au tutoriel sur les listview si jamais vous ne comprenez pas.

Le format des items pour notre listview

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="horizontal" android:layout_width="match_parent"
	android:layout_height="wrap_content">

	<TextView android:layout_height="fill_parent" android:layout_width="10dp" android:background="@android:color/white" android:id="@+id/ForceSignal"/>

	<LinearLayout android:orientation="vertical"
		android:layout_width="match_parent" android:layout_height="match_parent" android:paddingLeft="10dp">

		<TextView android:id="@+id/tvWifiName" android:layout_width="fill_parent"
			android:layout_height="wrap_content" android:text="AP Name" />

		<TextView android:id="@+id/tvWifiMac" android:layout_width="fill_parent"
			android:layout_height="wrap_content" android:textSize="10dp"
			android:text="00:00:00:00:00:00" />

	</LinearLayout>

</LinearLayout>

Notre main.xml

<?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"
    >
    <Button android:id="@+id/buttonRefresh" android:text="Rechercher" android:layout_width="fill_parent" android:layout_height="wrap_content"></Button>
    <ListView android:id="@+id/listViewWifi" android:layout_height="fill_parent" android:layout_width="match_parent"></ListView>
</LinearLayout>

La classe représentant notre item pour la listview

public class WifiItem {
	private String APName;
	private String AdresseMac;
	private int ForceSignal;

	public String getAPName() {
		return APName;
	}
	public void setAPName(String aPName) {
		APName = aPName;
	}
	public String getAdresseMac() {
		return AdresseMac;
	}
	public void setAdresseMac(String adresseMac) {
		AdresseMac = adresseMac;
	}
	public int getForceSignal() {
		return ForceSignal;
	}
	public void setForceSignal(int forceSignal) {
		ForceSignal = forceSignal;
	}	

}

Notre adapter

public class WifiAdapter extends BaseAdapter {

	private List<WifiItem> listeWifiItem;
	private LayoutInflater layoutInflater;

	public WifiAdapter(Context context, List<WifiItem> objects) {

			listeWifiItem = objects;
			layoutInflater = LayoutInflater.from(context);
	}

	public int getCount() {
		return listeWifiItem.size();
	}

	public Object getItem(int position) {
		return listeWifiItem.get(position);
	}

	public long getItemId(int position) {
		return position;
	}

	private class ViewWifiHolder {
		TextView tvApName;
		TextView tvAdresseMac;
		TextView ForceSignal;
	}

	public View getView(int position, View convertView, ViewGroup parent) {
		ViewWifiHolder viewHolder;

		if(convertView == null) {
			viewHolder = new ViewWifiHolder();

			convertView = layoutInflater.inflate(R.layout.item_wifi, null);

			viewHolder.tvApName = (TextView) convertView.findViewById(R.id.tvWifiName);
			viewHolder.tvAdresseMac = (TextView) convertView.findViewById(R.id.tvWifiMac);
			viewHolder.ForceSignal = (TextView) convertView.findViewById(R.id.ForceSignal);

			convertView.setTag(viewHolder);
		} else {
			viewHolder = (ViewWifiHolder)convertView.getTag();
		}

		// On affecte les valeurs
		viewHolder.tvApName.setText(listeWifiItem.get(position).getAPName());
		viewHolder.tvAdresseMac.setText(listeWifiItem.get(position).getAdresseMac());

		// On change la couleur en fonction de la force du signal
		if(listeWifiItem.get(position).getForceSignal() <= -80) {
			viewHolder.ForceSignal.setBackgroundColor(Color.GREEN);
		} else if(listeWifiItem.get(position).getForceSignal() <= -50) {
			viewHolder.ForceSignal.setBackgroundColor(Color.YELLOW);
		} else {
			viewHolder.ForceSignal.setBackgroundColor(Color.RED);
		}

		return convertView;
	}

}

Implémentation :

Passons désormais à l’implémentation de notre code, tout d’abord nous allons commencer par instancier tout les objets dont nous avons besoin.

private Button boutonRechercher;
private ListView listeViewWifi;
private List<WifiItem> listeWifiItem;
private WifiAdapter wifiAdapter;
private WifiManager wifiManager;
private WifiBroadcastReceiver broadcastReceiver;

• Le bouton de l’IHM
• La listview de l’IHM
• La liste des WifiItem
• Notre adapter
• Le wifi manager du sdk Android
• Le broadcast receiver que nous allons créer par la suite

Notre méthode onCreate

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

	listeViewWifi = (ListView) findViewById(R.id.listViewWifi);
	boutonRechercher = (Button) findViewById(R.id.buttonRefresh);

	boutonRechercher.setOnClickListener(new OnClickListener() {

		public void onClick(View v) {
			if(wifiManager != null)
				wifiManager.startScan();
		}
	});

	// On récupère le service Wifi d'Android
	wifiManager = (WifiManager) this.getSystemService(Context.WIFI_SERVICE);

	// Gestion de la liste des AP Wifi (Voir tuto sur les adapters et les
	// listview)
	listeWifiItem = new ArrayList<WifiItem>();
	wifiAdapter = new WifiAdapter(this, listeWifiItem);
	listeViewWifi.setAdapter(wifiAdapter);

	// Création du broadcast Receiver
	broadcastReceiver = new WifiBroadcastReceiver();

	// On attache le receiver au scan result
	registerReceiver(broadcastReceiver, new IntentFilter(
			WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));

}

On commence par récupèrer le bouton et la listview, ensuite on va lier notre wifiManager au service Android grâce au getSystemService.

Continuons en initialisant la liste d’objet et l’adapter.

Pour finir on va instancier notre broadcast receiver et l’enregistrer pour qu’il soit appelé à chaque fois qu’un scan des réseaux wifi est fait.

// On arrête le receiver quand on met en pause l'application
@Override
protected void onPause() {
	unregisterReceiver(broadcastReceiver);
	super.onPause();
}

// On remet en rourte le receiver quand on reviens sur l'application
@Override
protected void onResume() {
	registerReceiver(broadcastReceiver, new IntentFilter(
			WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));
	super.onResume();
}

N’oublions pas ces deux parties qui permette d’arrêter de recevoir les scans si vous avez mis l’application en arrière plan et de nouveau recevoir les scans si vous revenez sur celle-ci.

Pour terminer on fait des getters sur certaines de nos variables pour qu’elles soient accésibles dans le BroadcastReceiver.

public WifiManager getCurrentWifiManager() {
	return wifiManager;
}

public WifiAdapter getWifiAdapter() {
	return wifiAdapter;
}

public List<WifiItem> getListeWifiItem() {
	return listeWifiItem;
}

Passons maintenant à la création du BroadcastReceiver associé au wifi

public class WifiBroadcastReceiver extends BroadcastReceiver {

	private WifiManager wifiManager;
	private WifiAdapter wifiAdapter;
	private List<WifiItem> listeWifiItem;

	@Override
	public void onReceive(Context context, Intent intent) {
		wifiManager = ((FormationWifiActivity) context).getCurrentWifiManager();
		wifiAdapter = ((FormationWifiActivity) context).getWifiAdapter();
		listeWifiItem = ((FormationWifiActivity) context).getListeWifiItem();

		// On vérifie que notre objet est bien instancié
		if (wifiManager != null) {

			// On vérifie que le wifi est allumé
			if (wifiManager.isWifiEnabled()) {
				// On récupère les scans
				List<ScanResult> listeScan = wifiManager.getScanResults();

				// On vide notre liste
				listeWifiItem.clear();

				// Pour chaque scan
				for (ScanResult scanResult : listeScan) {
					WifiItem item = new WifiItem();

					item.setAdresseMac(scanResult.BSSID);
					item.setAPName(scanResult.SSID);
					item.setForceSignal(scanResult.level);

					Log.d("FormationWifi", scanResult.SSID + " LEVEL "
							+ scanResult.level);

					listeWifiItem.add(item);
				}

				// On rafraichit la liste
				wifiAdapter.notifyDataSetChanged();
			} else {
				Toast.makeText(context, "Vous devez activer votre wifi",
						Toast.LENGTH_SHORT);
			}
		}

	}

}

• On crée un classe qui hérite de BroadcastReceiver
• On redéfinie la méthode onReceive
• On récupère nos getter de l’activité
• On vérifie tout de même que le wifimanager est en route
• On vérifie aussi que le wifi est activé
• On récupère la liste des réseaux scannés
• On vide notre liste et on la remplie avec les nouvelles informations
• On spécifie à notre adapter que la liste à était modifiée

Et voilà le tour est joué, normalement vous pouvez voir tout les réseaux wifi à portée de votre mobile.

Le broadcast receiver est appelé à chaque fois qu’un scan est fait par l’OS.

En espérant que ce tutoriel vous sera utile.

Source : FormationWifi

Nous allons voir pas à pas comment utiliser ce dispositif et comment bien gérer notre application à ce niveau (merci les bonnes pratiques).

Pré requis :

• Un nouveau projet tout beau tout propre sous android 2.2
• Un téléphone ou une tablette

Permissions :

Nous devons ajouter des droits pour pouvoir utiliser la caméra

<uses-permission android:name="android.permission.CAMERA"></uses-permission>
<uses-feature android:name="android.hardware.camera"/>
<uses-feature android:name="android.hardware.camera.autofocus"/>

Orientation de l’activite :

Il est tout de même plus facile de filmer ou prendre une photo en mode paysage

android:screenOrientation="landscape"

Contenu global de notre fichier manifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.aceart.FormationCamera"
      android:versionCode="1"
      android:versionName="1.0" android:installLocation="auto">
    <uses-sdk android:minSdkVersion="10" />
    <uses-permission android:name="android.permission.CAMERA"></uses-permission>
    <uses-feature android:name="android.hardware.camera"/>
    <uses-feature android:name="android.hardware.camera.autofocus"/>

    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".FormationCameraActivity"
                  android:label="@string/app_name" android:screenOrientation="landscape">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

Commençons à coder

Nous allons avoir besoin tout d’abord d’une surface pour prévisualiser l’image que nous renvoie l’appareil photo. Il faut ajouter une SurfaceView à notre layout, comme ceci :

<?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"
    >
    <SurfaceView android:id="@+id/surfaceViewCamera" android:layout_width="fill_parent" android:layout_height="fill_parent"></SurfaceView>
</LinearLayout>

Une fois ceci fait, rentrons dans le vif du sujet avec la partie java, comme d’habitude celle-ci est plus que cruciale dans vos développements, mais quand on joue avec un dispositif tel que l’appareil photo il faut prendre de soin de libérer celui-ci lorsque l’on ne l’utilise plus.

Tout d’abord nous allons implémenter une interface nommée SurfaceHolder.Callback à notre activité qui permettra d’avoir les retours sur notre SurfaceView et nous permettre d’afficher en temps réel notre prévisualisation.

public class FormationCameraActivity extends Activity implements SurfaceHolder.Callback

Une fois l’interface implémentée il à l’aide d’Eclipse nous devons avoir 3 fonctions supplémentaires

public void surfaceChanged(SurfaceHolder holder, int format, int width,int height)
public void surfaceCreated(SurfaceHolder holder)
public void surfaceDestroyed(SurfaceHolder holder)

Crééons maintenant 3 variables locales dans notre activité

private Camera camera;
private SurfaceView surfaceCamera;
private Boolean isPreview;

La première contiendra notre Camera, la seconde notre surface pour la prévisualisation et pour finir connaître l’état de la prévisualisation.

Dirigeons nous vers méthode onCreate ou nous allons ajouter de nouvelles fonctionnalités

@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	// On met l'application en plein écran et sans barre de titre
	getWindow().setFormat(PixelFormat.TRANSLUCENT);
	requestWindowFeature(Window.FEATURE_NO_TITLE);
	getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
			WindowManager.LayoutParams.FLAG_FULLSCREEN);

	isPreview = false;

	// On applique notre layout
	setContentView(R.layout.main);

	// On récupère notre surface pour le preview
	surfaceCamera = (SurfaceView) findViewById(R.id.surfaceViewCamera);

	// Méthode d'initialisation de la caméra
	InitializeCamera();
}

On commence tout d’abord par définir les propriétés de notre activite, sans barre de titre et en plein écran.

On initialise notre prévisualisation a faux et on récupére notre SurfaceView.

Pour terminer on appelle notre méthode pour initialiser notre caméra.

public void InitializeCamera() {
	// On attache nos retour du holder à notre activite
	surfaceCamera.getHolder().addCallback(this);

	// On spécifie le type du holder en mode SURFACE_TYPE_PUSH_BUFFERS
	surfaceCamera.getHolder().setType(
			SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}

On récupère le holder de notre surface et on attache son callback à l’activite, c’est d’ailleurs pour ça que l’on a implémenté notre interface.

On définie ensuite le type du holder, si vous l’oubliez vous aurez droit à un magnifique crash de votre application.

Définissons maintenant nos méthodes implémentées par l’interface.

public void surfaceDestroyed(SurfaceHolder holder) {
	// On arrête la camera et on rend la main
	if (camera != null) {
		camera.stopPreview();
		isPreview = false;
		camera.release();
	}
}

Quand la surface est détruite, on arrête la prévisualisation, on met notre jeton isPreview à false puis on libère le périphérique (c’est important).

public void surfaceCreated(SurfaceHolder holder) {
	// On prend le controle de la camera
	if (camera == null)
		camera = Camera.open();
}

Quand la surface est créé on ouvre le périphérique pour pouvoir capturer.

// Quand la surface change
public void surfaceChanged(SurfaceHolder holder, int format, int width,
		int height) {

	// Si le mode preview est lancé alors on le stop
	if (isPreview) {
		camera.stopPreview();
	}
	// On récupère les parametres de la camera
	Camera.Parameters parameters = camera.getParameters();

	// On change la taille
	parameters.setPreviewSize(width, height);

	// On applique nos nouveaux parametres
	camera.setParameters(parameters);

	try {
		// On attache notre previsualisation de la camera au holder de la
		// surface
		camera.setPreviewDisplay(surfaceCamera.getHolder());
	} catch (IOException e) {
	}

	// On lance la previeuw
	camera.startPreview();

	isPreview = true;
}

• On commence par vérifier si on est en train de capturer la prévisualisation, si oui on stop le processus,
• On récupère les paramétres actuels de notre object Camera, ensuite on lui attribut la nouvelle taille de la surface pour projeter notre prévisualisation
• On set les nouveaux paramètres
• On indique a notre camera qu’il faut rediriger la prévisualisation sur notre surface
• Pour finir on lance la prévisualisation
• On met notre jeton à true

Pour terminer on oublie pas ces deux parties

// Retour sur l'application
@Override
public void onResume() {
	super.onResume();
	camera = Camera.open();
}

// Mise en pause de l'application
@Override
public void onPause() {
	super.onPause();

	if (camera != null) {
		camera.release();
		camera = null;
	}
}

Elles vont vous permettre de gérer la mise en arrière plan et le retour au premier plan de l’application, en libérant la caméra de votre emprise (bande de tirans).

Pour terminer notre petit tutoriel nous allons voir comment enregistrer une image (c’est le but en fin de compte).

Prendre une photo

Nous allons rajouter un peut de code dans notre méthode onCreate, pour que l’on puisse prendre une photo lorsque l’on appuye sur l’écran.

// Quand on clique sur notre surface
surfaceCamera.setOnClickListener(new OnClickListener() {

	public void onClick(View v) {
		// On prend une photo
		if (camera != null) {
			SavePicture();
		}

	}
});

On attache l’évenement onClick de notre SurfaceView a un listener.

Si l’évenement est levé on appel notre méthode SavePicture.

private void SavePicture() {
	try {
		SimpleDateFormat timeStampFormat = new SimpleDateFormat(
				"yyyy-MM-dd-HH.mm.ss");
		String fileName = "photo_" + timeStampFormat.format(new Date())
				+ ".jpg";

		// Metadata pour la photo
		ContentValues values = new ContentValues();
		values.put(Media.TITLE, fileName);
		values.put(Media.DISPLAY_NAME, fileName);
		values.put(Media.DESCRIPTION, "Image prise par FormationCamera");
		values.put(Media.DATE_TAKEN, new Date().getTime());
		values.put(Media.MIME_TYPE, "image/jpeg");

		// Support de stockage
		Uri taken = getContentResolver().insert(Media.EXTERNAL_CONTENT_URI,
				values);

		// Ouverture du flux pour la sauvegarde
		stream = (FileOutputStream) getContentResolver().openOutputStream(
				taken);

		camera.takePicture(null, pictureCallback, pictureCallback);
	} catch (Exception e) {
		// TODO: handle exception
	}

}

• On commence par définir un format de nommage pour nos photos
• Puis on définie toutes propriétés pour le mettre dans la base de données des photos
• On récupère le chemin d’insertion
• On ouvre le flux d’écriture
• On lance le camera.takePicture pour prendre une photo

Pour finir il faut implémenter le pictureCallback

// Callback pour la prise de photo
Camera.PictureCallback pictureCallback = new Camera.PictureCallback() {

	public void onPictureTaken(byte[] data, Camera camera) {
		if (data != null) {
			// Enregistrement de votre image
			try {
				if (stream != null) {
					stream.write(data);
					stream.flush();
					stream.close();
				}
			} catch (Exception e) {
				// TODO: handle exception
			}

			// On redémarre la prévisualisation
			camera.startPreview();
		}
	}
};

• On enregistre nos données dans le stream
• On écrit en dur sur la sdcard
• On ferme le flux
• On rélance la prévisualisation

Et pour terminer !

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

Si jamais vous en avez besoin.

Voilà désormais nous allons chercher notre photo dans la galerie et on regarde son détail

Et voilà tout est là !

J’espère que ce tuto vous auras plus.

Source : FormationCamera

Pour commencer nous allons apprendre à utiliser les actions bar comme celle-ci :



Il est en effet plus pratique sous Honeycomb d’utiliser une action bar qu’un menu qui apparait et disparait lorsque l’on clique sur le bouton menu.

Vous aurez remarqués que par défaut le bouton menu n’existe plus sur l’interface, ce n’est pas un mal il faut seulement passer ce menu dans l’action bar.

Pré-requis :

• Android 3.1
• Eclipse
• Une tablette si possible (l’émulateur est assez lent pour développer)

Présentation :

Commençons par créer un nouveau projet sous Android 3.1, une fois ceci fait vous remarquerez que l’arborescence des répertoires n’a pas changé.

Ouvrez maintenant le fichier main.xml qui nous servira de base, vous devriez voir apparaitre la nouvelle interface de création fournie par google avec notre main.xml dedans.

Cette nouvelle interface est plus intuitive que ses versions précédentes, nous avons donc un aperçu directe de sa représentation sur Honeycomb.

Création du menu :

Nous allons créer un nouveau menu pour notre application comme ceci :

Une fois le menu créé il faut maintenant le renseigner avec des valeurs

<?xml version="1.0" encoding="utf-8"?>

<menu xmlns:android="http://schemas.android.com/apk/res/android">

	<item android:title="Afficher une popup" android:id="@+id/itemDialog"></item>
	<item android:title="Quitter" android:id="@+id/itemExit"></item>

</menu>

Voici notre code, deux actions :

• La première affichera une popup disant « Hello world »
• La deuxième quittera l’application

Maintenant il faut que le menu soit utilisable dans notre application, pour cela dirigeons nous vers notre Activity.

Par défaut le menu ne s’affiche pas, il faut le rajouter à notre activité, pour cela il faut utiliser la méthode onCreateOptionsMenu comme ceci :

@Override

public boolean onCreateOptionsMenu(Menu menu) {
	getMenuInflater().inflate(R.menu.menuhoney, menu);
	return super.onCreateOptionsMenu(menu);
}

Lancez l’application et voyez par vous-même !

Nous avons créé notre tout premier menu dans l’Action Bar.

Vous allez me dire oui mais j’aimerais que « Afficher une popup » apparaisse directement dans la fenêtre sans passer par le bouton.

Rien de plus simple il suffit d’aller dans notre menu et de rajouter l’option suivante :

android:showAsAction=”ifRoom”

Pour notre bouton ce qui doit vous donner cela

<?xml version="1.0" encoding="utf-8"?>

<menu xmlns:android="http://schemas.android.com/apk/res/android">

	<item android:title="Afficher une popup" android:id="@+id/itemDialog" android:showAsAction="ifRoom"></item>
	<item android:title="Quitter" android:id="@+id/itemExit"></item>

</menu>

Relançons notre application maintenant

Notre bouton action est de sortie dans l’Action Bar.

Vous pouvez attribuer une icône à cette action, mais par défaut il n’y aura que l’icône dans la barre, il faudra alors rajouter android:showAsAction=”ifRoom|withText” si vous voulez voir apparaître le texte.

Par contre, c’est bien jolie, mais il faudrait maintenant que lorsqu’on clic sur les actions qu’il y est quelque chose qui se passe.

Android a tout prévu !

onOptionsItemSelected va faire votre bonheur je vous l’assure

@Override
public boolean onOptionsItemSelected(MenuItem item) {
	switch (item.getItemId()) {
		case R.id.itemDialog:
			OuvrirUnePopup();
			return true;
		case R.id.itemExit:
			this.finish();
			return true;
		default:
			return super.onOptionsItemSelected(item);
	}
}

private void OuvrirUnePopup() {
	AlertDialog.Builder builder = new AlertDialog.Builder(this);
	builder.setMessage("Bonjour tout le monde")
		.setCancelable(false)
		.setPositiveButton("Fermer", new DialogInterface.OnClickListener() {
			public void onClick(DialogInterface dialog, int id) {
				dialog.cancel();
		}
	});

	AlertDialog alert = builder.create();

	alert.show();

}

C’est quand même facile.

Recherche :

On a bien progressé mais on aimerait bien avoir une barre de recherche dans notre application comme celle-ci :

C’est tout de même plus pratique si nous avons des données à rechercher comme dans beaucoup d’applications.

Mais encore une fois Android a tout prévu, son vraiment sympa chez Google !

Rajoutons un menu dans notre menuhoney.xml

<item android:id="@+id/itemSearch" android:showAsAction="ifRoom" android:actionViewClass="android.widget.SearchView" android:title="Recherche"></item>

Cette fois-ci on va prendre la classe android.widget.SearchView qui permet de faire ça directement, pas besoin de passer 2h à tout recoder.

Lançons l’application encore une fois

Super notre barre de recherche s’affiche, par contre elle ne fait que s’afficher, il va falloir la faire fonctionner.

Etapes :

• Récupérer le SearchView
• Lier un listener sur setOnQueryTextListener
• Faire une action sur onQueryTextSubmit

@Override
public boolean onCreateOptionsMenu(Menu menu) {
	getMenuInflater().inflate(R.menu.menuhoney, menu); 
	SearchView searchView = (SearchView) menu.findItem(R.id.itemSearch).getActionView(); 

	searchView.setOnQueryTextListener(new OnQueryTextListener() { 

		@Override
		public boolean onQueryTextSubmit(String query) {
			OuvrirUnePopup(query);
			return false;
		}

		@Override
		public boolean onQueryTextChange(String newText) {
			return false;
		}

	});

	return super.onCreateOptionsMenu(menu);

}

Et voilà ce que cela donne au final !

Vous voilà désormais fin prêt à faire des actions bar dans vos applications honeycomb !

Sources : FormationHoneyBar