Construire dynamiquement ses IHM Android.

Image non disponible
Android2EE

Image non disponible

Android2ee


La Formation et l'Expertise Android à votre service


Comme AirFrance , Orange, Capgemini , Atos WorldLine et bien d'autres.
Vous aussi,
Bénéficiez des meilleures formations Android du moment


Cet article vous explique comment mettre en place dynamiquement des I.H.M. Par contre, je vous préviens tout de suite, c'est un cas très rare. La seule fois où j'ai effectué cette mise en place fut lors de la construction d'un calendrier. Et dans ce cas, ce qui était dynamique n'était pas l'inflation des vues mais le positionnement des cellules des rendez-vous dans un RelativeLayout pour qu'elles se placent dans le créneau horaire voulu. Je ne préconise pas de construire ses I.H.M. dynamiquement. Si vous pouvez le faire de manière statique faîtes le et utilisez au mieux la spécification de vos dossier de layout vis-à-vis de la configuration de l'appareil (layout-land, layout-large, layout-large-land...). Bref, La construction dynamique des I.H.M. est pour moi une mauvaise pratique.




Android2EE est référencé en tant qu'organisme de formation, vous pouvez faire prendre en charge tout ou partie du montant de cette formation par votre OPCA. Cette formation Initiation avancée à Android est éligible au titre du DIF et CIF.

5 commentaires

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

0. Avertissement

J'ai rédigé cet article, il y a plus de trois ans, depuis j'ai quelque peu modifié ma vision des patterns à utiliser lors de la construction dynamique des IHM.

La première chose qu'il faut que vous gardiez en tête est qu'il ne faut jamais utiliser de new dans l'instanciation d'un composant graphique. J'ai compris cela en discutant avec Romain Guy (à charge de l'optimisation graphique Android à Montain View) lors de la DevoxxFrance en Avril. En effet, il faut utiliser le LayoutInflater.inflate et surtout pas de new. La raison est assez simple, le new contourne toute la couche d'optimisation mise en place par le système, celui-ci ne peut donc rien optimiser ni gérer avec efficience les composants graphiques. Il faut donc utiliser les LayoutInflaters pour instancier ces composants graphiques. Une seconde raison qui m'a été donnée par nicroman (de DVP) est qu'il est possible de définir dans vos fichiers xml des balises qui ne sont pas prises en compte si le système ne les reconnait pas ; une balise JellyBean nouvelle ne ferra pas planter votre application si vous la définissez en Xml, même si votre application tourne sur Froyo, alors que la même chose avec du code n'est pas possible.

Ainsi, vous devez définir vos briques minimales (les plus petits éléments communs qui vous serviront à construire votre IHM) en tant que fichiers Xml. Ces briques peuvent être de simples composants graphiques (TextView, Button, ImageView,.) ou des composants plus évolués construis avec des layouts.

Quand vous avez à instancier l'élément vous utiliser le LayoutInflater pour lui donner vie. Vous pouvez alors le manipuler comme expliqué dans l'article.

Pour récupérer le LayoutInflater, c'est assez facile.

Dans le cas où vous êtes dans un Fragment, il vous suffit de conserver un pointeur sur le LayoutInflater qui vous est fourni dans la méthode :

 
Sélectionnez
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
	this.inflater = inflater;


Dans le cas où vous êtes dans une Activité, la méthode getLayoutInflater() est faite pour ça.


Il ne vous reste plus qu'à instancier vos composants ainsi :

 
Sélectionnez
// Instanciation d'un composant (par exemple un Layout) 
LinearLayout evtCell = (LinearLayout) inflater.inflate(R.layout.calendar_event_cell, null); 

Où la méthode inflate possède deux paramètres, le premier indique le nom de la ressource à instancier, le second indique à quel élément ajouter ce composant graphique (son layout parent). Ci-dessous la JavaDoc de la méthode inflate :

0-0-0-0-1. View android.view.LayoutInflater.inflate(int resource, ViewGroup root)

Inflate a new view hierarchy from the specified xml resource. Throws InflateException if there is an error.

Parameters:

resource ID for an XML layout resource to load (e.g., R.layout.main_page)

root Optional view to be the parent of the generated hierarchy.

Returns:

The root View of the inflated hierarchy. If root was supplied, this is the root View; otherwise it is the root of the inflated XML file.


Ainsi, vous définissez vos plus petits composants graphiques en Xml, vous utiliser le LayoutInflater pour les instancier et vous pouvez alors créer proprement vos IHM de manière dynamique comme indiqué dans cet article.

Bonne lecture.

1. Introduction

La construction d'Interfaces Hommes-Machines dynamique est à réserver au cas très particulier de la mise en place d'écrans qui s'adaptent aux données qu'ils doivent afficher et qui ne peuvent être connues par avance.

Un exemple typique est la construction d'IHM à partir d'un flux de données XML provenant d'un serveur web. La structure du flux est connue mais pas les données (taille des listes typiquement). Il y a bien d'autres cas où cela peut être utile de savoir construire les IHM dynamiquement. Vous trouverez certainement tout un tas de cas où une construction à la volée simplifie grandement l'implémentation d'un besoin.

Dans ce cas, il est très utile de pouvoir construire une IHM qui s'adapte parfaitement au flux reçu. C'est l'objectif de cet article que de vous donner les clefs pour réaliser une construction dynamique en toute simplicité.

2. Principe

Le principe est assez similaire à la construction d'un écran quand on fait du swing (ou d'autres langages de construction graphique).

Vous définissez votre layout, vous y placez vos composants :

// Définition du Layout à construire.

LinearLayout postLayout = new LinearLayout( this );

// Définition du composant Text.

TextView txvName = new TextView( this );

txvName .setText(String. format (getString(R.string. wall_name ), post .getString( "name" )));

txvName .setTypeface(Typeface. defaultFromStyle (Typeface. BOLD ));


// Définition de la façon dont le composant va remplir le layout.

LinearLayout.LayoutParams layoutParam = new LinearLayout.LayoutParams(LinearLayout.LayoutParams. FILL_PARENT ,LinearLayout.LayoutParams. WRAP_CONTENT ) ;

// Ajout du composant au layout.

postLayout .addView( txvName , layoutParam );

Cela devient plus subtil, quand on souhaite modifier une IHM existante. Dans ce cas, il vous faut d'abord supprimer le contenu du layout à reconstruire, puis le remplir à nouveau :

// Tout d'abord, il faut détruire tous les éléments contenus dans le layout.

LinearLayout layoutOfDynamicContent = ( LinearLayout ) findViewById(R.id. layoutOfDynamicContent );

layoutOfDynamicContent .removeAllViewsInLayout();

//Ajouter les composants à ce layout. Votre IHM va être mise à jour.


Vous remarquerez que l'on ne détruit pas le layout, mais son contenu. C'est d'ailleurs ce contenu qui est entièrement reconstruit.


Enfin, un élément important à garder en tête est le cycle de vie de votre activité. Si vous ne mettez pas en place la sauvegarde de vos données lors des changements d'état (au sein des méthodes onPause, onResume), votre application rechargera entièrement les données à partir du serveur. Il vous faut donc être attentif à ce point.

3. Mise en place

3-1. Structure du projet

Le projet est structuré de manière classique. Votre activité est associée à un fichier de layout qui ne décrit que les éléments qui sont statiques à votre IHM.

Pour le reste rien n'est changé.

3-2. Du code par l'exemple

Étant donné qu'il n'y a pas de concept spécifique à assimiler pour construire dynamiquement des IHM à la volée. Le mieux est d'aller directement dans le code et d'expliquer celui-ci. Ce code provient du tutoriel « DynamicGui » disponible sur Android2ee.com à la rubrique « Exemples ». L'application de cet exemple a pour objectif d'afficher la liste d'éléments dont la structure est la suivante :

Nom du champ Type de la donnée
Titre String
Description String
Messages List<Message>
FromWebPicture Drawable


Où l'objet Message est le suivant :

Titre String
Message String
From String
FromPicture Drawable


Les contraintes sont que la taille des listes est inconnue, seule la structure des données est connue par avance. De même les images sont à récupérer soit sur le web via leur URL, soit dans le dossier ressource\drawable de l'application.

3-2-1. Les fichiers usuels de l'application

3-2-1-1. Le fichier AndroidManifest

Le manifeste Android est un fichier androidManifest.xml banal, ni l'application, ni le système ne savent que vous construisez dynamiquement votre écran.

Dans cet exemple, il définit l'application, son unique activité, la version minimale du système à utiliser et pour pouvoir aller récupérer des images via leur URL, il demande l'accès à internet.

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

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

package = "com.android2ee.tuto.gui"

android:versionCode = "1"

android:versionName = "1.0" >

< application android:icon = "@drawable/icon" android:label = "@string/app_name" >

< activity android:name = ".DynamicGui"

android:label = "@string/app_name" >

< intent-filter >

< action android:name = "android.intent.action.MAIN" />

< category android:name = "android.intent.category.LAUNCHER" />

</ intent-filter >

</ activity >


</ application >

< uses-sdk android:minSdkVersion = "8" />

<!-- Permission pour accéder à internet (usuel )-->

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

</ manifest >

3-2-2. Le fichier de layout

Ce fichier décrit les composants statiques de l'IHM. Dans cet exemple, il définit :

  • le layout principal de l'activité ;
  • un label affichant la chaine de caractères « Bonjour » ;
  • un bouton permettant de relancer la construction dynamique de l'IHM ;
  • et enfin, le layout qui contiendra la vue reconstruite dynamiquement.

Ce qui donne :

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

android:id = "@+id/mainlayout" >


< TextView android:layout_width = "fill_parent"

android:layout_height = "wrap_content"

android:text = "@string/hello"

android:id = "@+id/txvHello" />


< Button android:text = "@string/reload"

android:id = "@+id/btnReload"

android:layout_width = "wrap_content"

android:layout_height = "wrap_content" ></ Button >


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

android:orientation = "vertical"

android:layout_width = "fill_parent"

android:layout_height = "fill_parent"

android:id = "@+id/layoutOfDynamicContent" >

</ LinearLayout >

</ LinearLayout >

3-2-3. Destruction de la vue et son réaffichage

Il faut tout d'abord détruire le contenu de votre layout puis le reconstruire. La méthode à utiliser pour la destruction du contenu de votre layout est removeAllViewsInLayout(); (la méthode removeAllViews() ne marche pas). Un grand merci à Yan Verdavaine de développez.com pour m'avoir ouvert les yeux. Encore une fois, merci Monsieur.

Ensuite, il vous suffit d'ajouter vos composants à ce layout. Votre IHM sera mise à jour automatiquement.

Ce qui donne :

// Tout d'abord, il faut détruire tous les éléments contenus dans le layout.

LinearLayout layoutOfDynamicContent = ( LinearLayout ) findViewById(R.id. layoutOfDynamicContent );

layoutOfDynamicContent .removeAllViewsInLayout();

//Ajouter les composants à ce layout.

//Cf. paragraphes suivants.

//Et c'est tout votre layout qui va être mis à jour automatiquement.

3-2-4. Gestion du placement des composants au sein des layouts

L'un des points-clefs dans la construction d'IHM, dynamique ou pas, est le placement des composants au sein des layouts. En effet, outre le choix du layout, il faut arriver à positionner proprement son composant en son sein. En particulier, les définitions de son comportement en largeur et hauteur (android:layout_width et android:layout_height), de sa marge, de sa gravité sont des éléments décisifs pour la mise en place de votre écran.

Dans cet article, je n'aborderai que le cas du layout LinearLayout.

Voici, le code permettant de définir un LinearLayout et de lui ajouter un composant en gérant les marges, la gravité, sa largeur et sa hauteur.

// Paramètres généraux du layout :


//Déclaration du layout et instanciation de celui-ci.

LinearLayout lilPost = new LinearLayout( this );

//Définition de son orientation.

lilPost .setOrientation(LinearLayout. VERTICAL );

//Définition de son padding (le padding est la distance en pixels, entre le bord du composant et son contenu).

lilPost .setPadding(0, 15, 0, 0);

//Définition de la couleur de fond du layout.

lilPost .setBackgroundColor(0xFF007AAD);

.

.

// Paramètres spécifiques au placement du composant webPicture au sein du layout :


//Définition du paramètre de placement du composant au sein du layout et instanciation (avec la spécification de la manière dont le composant va remplir l'espace).

LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams. WRAP_CONTENT , LinearLayout.LayoutParams. WRAP_CONTENT );

//Définition de la gravité du composant (comment il se positionne au sein de la zone qui lui est allouée).

params . gravity =Gravity. CENTER_HORIZONTAL ;

//Définition des marges du composant (distance, en pixels, autour du composant).

params .setMargins(5, 5, 5, 5);

//Ajout du composant dans le layout avec les paramètres de positionnement définis ci-dessus.

lilPost .addView( webPicture , params );

Ce code est équivalent au fichier xml suivant :

< LinearLayout android:id = "@+id/ lilPost "

android:orientation = " vertical "

android: paddingLeft = " 5 "

android: paddingRight = " 5 "

android: paddingTop = " 5 "

android: paddingBottom = " 5 "

android :background = " # 007AAD"

>

< ImageButton

android:id = "@+id/ webPicture "

android:layout_width = " wrap_content "

android:layout_height = " wrap_content "

android: layout_marginLeft = " 5 "

android: layout_marginRight = " 5 "

android: layout_marginTop = " 5 "

android: layout_marginBottom = " 5 "

android:gravity ="center_horizontal"

>

</ ImageButton >

</ LinearLayout >

3-2-5. Gestion du Scroll

Dans la problématique de l'affichage d'une vue construite dynamiquement se pose souvent la question du scroll. En effet, la construction dynamique implique souvent l'incapacité à prévoir la taille que prendront nos données. Il nous faut ainsi souvent prévoir une Scroll Bar.

Sous Android le composant ScrollView ne peut posséder qu'un enfant. Cet enfant se doit donc d'être votre layout contenant les composants ajoutés dynamiquement. De même il devrait remplir l'espace en largeur et en hauteur du layout principal dans lequel il se place.

Ainsi nous obtenons le code suivant :

//Tout d'abord, il faut supprimer tous les éléments du layout principal.

//Ce layout est déjà chargé par ailleurs.

layoutOfDynamicContent .removeAllViewsInLayout();


//Ensuite il faut définir et instancier la ScrollView.

//le this correspond à l'Activité contenant ces lignes.

ScrollView scvMain = new ScrollView( this );

//On définit la couleur de fond du scroll.

scvMain .setBackgroundColor(0xFFCFDBEC);

//Et on rajoute la ScrollView au layout principal en lui demandant de remplir tout l'espace disponible.

layoutOfDynamicContent .addView( scvMain , new LinearLayout.LayoutParams(LinearLayout.LayoutParams. FILL _CONTENT , LinearLayout.LayoutParams. FILL _CONTENT ) );


//Ensuite on définit le layout qui contiendra les composants ajoutés dynamiquement.

LinearLayout lilContent = new LinearLayout( this );

//code de construction dynamique de l'IHM.


//Ajout du layout à la ScrollView en lui demandant de remplir tout l'espace disponible.

scvMain .addView( lilContent , new LinearLayout.LayoutParams(LinearLayout.LayoutParams. FILL _CONTENT , LinearLayout.LayoutParams. FILL _CONTENT ) );

3-2-6. Gestion des composants usuels

Le composant TextView est la classe mère de quasiment tous les composants graphiques Android. Pour cette raison, cet article se focalise sur ce composant. D'autant que cet article a pour but de décrire comment générer dynamiquement une IHM, pas de comment manipuler les composants.

Le code suivant montre comment :

  • déclarer et instancier le composant ;
  • lui affecter un texte, une couleur de fond et une couleur de texte ;
  • définir sa police de caractères et son type face (Bold, Italic, Normal) ;
  • définir le texte à afficher par défaut quand le composant n'a pas de texte à afficher ;
  • positionner la sauvegarde automatique de l'état du composant associé au cycle de vie de l'activité ;
  • gérer son scrolling ;
  • gérer sa visibilité ;
  • et enfin, l'ajouter au layout qui est censé le contenir.

//Tout d'abord, déclarez et instanciez le composant en lui passant son Contexte.

//Ici le contexte n'est autre que l'activité dans lequel l'IHM est construite, d'où le this.

TextView txvTitle = new TextView( this );


//Affectation du texte à afficher par le composant.

txvTitle .setText( "titre : " + post .getString( "titre" ));

//Affectation de sa couleur de fond.

txvTitle .setBackgroundColor(0xFF627AAD);

//Affectation de sa couleur de text.

txvTitle .setTextColor(0xFFFFFFFF);

//Définition du typeFace du composant (Italic, Bold, Normal,Bold_Italic), un autre type de typeFace étant la police : MonoSpace, Sans_Serif, Serif.

txvTitle .setTypeface(Typeface. defaultFromStyle (Typeface. BOLD ));

//Le texte à afficher quand il n'y a aucun texte à afficher par le composant (i.e. quand le composant n'a rien à afficher).

txvTitle .setHint( "C'est quoi un HintText" );

//La couleur du hint-texte.

txvTitle .setHintTextColor(0xFF555555);


//Pour permettre de sauver en mémoire l'état du composant quand l'activité sera détruite pour être restauré plus tard.

txvTitle .setFreezesText( true );


//Ajout d'une scroll bar au composant.

txvTitle .setHorizontallyScrolling( true );

//Mise en place d'une ligne de transparence horizontale (à droite et à gauche) lors du scroll du composant ou setVerticalFadingEdgeEnabled pour mettre cette ligne verticale (en haut et en bas), ou les deux. Si le composant n'a pas de scrollBar, cela ne fera rien.

txvTitle .setHorizontalFadingEdgeEnabled( true );

//Définition de la hauteur/largeur de cette ligne de transparence.

txvTitle .setLines(2);


//Gérez la visibilité du composant, il peut être Visible, Invisible (caché mais l'espace pour le composant reste réservé) ou Gone (caché et l'espace du composant est libéré et utilisé par les autres composants).

txvTitle .setVisibility(View. VISIBLE );

//Et ainsi de suite, explorez l'API.


//Et ajout du composant au layout qui le contient.

lilPost .addView( txvTitle , new LinearLayout.LayoutParams(LinearLayout.LayoutParams. FILL _CONTENT , LinearLayout.LayoutParams. FILL _CONTENT ) );

3-2-7. Gestion des composants images

La gestion des composants de type image implique qu'il faut récupérer l'image à partir d'une chaine de caractères représentant son nom et l'affecter au composant. Ce paragraphe explique comment effectuer cette opération dans deux cas de figure :

  • l'image est une ressource de votre application (dans un dossier res\drawable-**) ;
  • l'image est une ressource du web (dont l'URL est connue, de type http://adresseWeb) ;

Un composant de type image est soit ImageView soit ButtonView, cela n'a pas d'importance ici, le traitement est identique.

Dans les deux cas, le code pour créer le composant est le même, seule la récupération de l'objet Drawable diffère :

//Définition et instanciation du composant Image.

ImageView webPicture = new ImageView( this );

//Le drawable à afficher.

Drawable monDrawable = //Le Drawable à affecter ;

//Affectation du composant à l'image.

webPicture .setImageDrawable( //Le Drawable à affecter );

//Définition de la couleur de fond du composant (facultatif).

webPicture .setBackgroundColor(0xFFFFFFFF);

3-2-7-1. Cas d'une image contenue dans les ressources de l'application

Pour récupérer de manière dynamique une image contenue dans le dossier de ressources à partir de la chaine de caractères représentant son nom, il faut réussir à retrouver son identifiant. Muni de cet identifiant le chargement de la ressource est naturel.

int pictureId =getResources().getIdentifier( message .getString( "fromPicture" ), "drawable" , "com.android2ee.tuto.gui" );

picture .setBackgroundDrawable(getResources().getDrawable( pictureId ));

La méthode getResources appartient à la classe ContextWrapper dont étend Activity (entre autres) et renvoie un objet de type Resources. Cette classe (Resources) permet de manipuler les ressources de l'application, en particulier leur récupération.

3-2-7-1-1. La méthode getIdentifier

La méthode public intgetIdentifier(Stringname,StringdefType,StringdefPackage)permet de retrouver l'identifiant généré par le compilateur pour une ressource particulière. Il suffit de lui passer le nom de la ressource, son type et le package racine de votre application (ou de l'application dans laquelle se trouve la ressource). Pour ce qui est du type, ce paramètre n'est autre que celui que l'on retrouve en seconde position dans l'appel usuel à un identifiant, par exemple :

  • R.string.maChaine a pour type string ;
  • R.layout.monLayout a pour type layout ;
  • R.drawable.monImage a pour type drawable ;
  • R.id.monComposant a pour type id.

Pour comprendre vraiment, il suffit de regarder le fichier de ressources R généré lors de la compilation :

/* AUTO-GENERATED FILE. DO NOT MODIFY.

*

* This class was automatically generated by the

* aapt tool from the resource data it found. It

* should not be modified by hand.

*/


package com.android2ee.tuto.gui;


public final class R {

public static final class attr {

}

public static final class drawable {

public static final int icon =0x7f020000;

public static final int icon_sti1 =0x7f020001;

public static final int icon_sti2 =0x7f020002;

public static final int icon_sti2b =0x7f020003;

public static final int icon_sti3 =0x7f020004;

}

public static final class id {

public static final int btnReload =0x7f050002;

public static final int layoutOfDynamicContent =0x7f050003;

public static final int mainlayout =0x7f050000;

public static final int txvHello =0x7f050001;

}

public static final class layout {

public static final int main =0x7f030000;

}

public static final class string {

public static final int app_name =0x7f040001;

public static final int hello =0x7f040000;

public static final int reload =0x7f040002;

}

}

La méthode getIdentifier(Stringname,StringdefType,StringdefPackage) devient alors limpide :

  • le paramètre defPackage est le package du fichier ;
  • le paramètre defType est le nom de classe contenant votre identifiant (la publicstaticfinalclass) ;
  • le paramètre name est le nom de l'identifiant contenu dans cette classe.

3-2-7-2. Cas d'une image provenant du web

Pour récupérer une image hébergée sur le web, je préconise l'utilisation de la méthode suivante :

/**

* Cette méthode renvoie le Drawable associé à une URL d'image

* @param urlPath l' URL de l'image

* @return L'objet Drawable téléchargé à partir de l' URL passée en paramètre

*/

private Drawable getPicture (String urlPath ) {

// Le drawable à renvoyer

Drawable drawable = null ;

try {

// Récupération de l'URL à partir de sa représentation sous forme de String.

URL URL = new URL ( urlPath );

//Ouverture de l'inputStream associé à cette URL pour sa lecture.

InputStream is = (InputStream) URL .getContent();

// Construction du Drawable à partir de ce flux entrant.

drawable = Drawable. createFromStream ( is , "src" );

} catch (IOException e ) {

Log. e ( tag , e .toString());

// Si une exception se produit faire quelque chose d'intelligent.

}

// Renvoyer le résultat.

return drawable ;

}

Cette méthode ne fait rien de plus qu'ouvrir un flux entrant sur l'URL de l'image et à partir de ce flux construit l'objet graphique Drawable souhaité.

L'utilisation de cette méthode est elle aussi « triviale » :

// Instanciation du composant image.

ImageView webPicture = new ImageView( this );

// Récupération du Drawable par appel à la méthode getPicture et affectation au composant.

webPicture .setImageDrawable(getPicture( http://nomDeLImage ));

3-2-8. Mise en place de données factices pour les tests

Je préconise, lors de la mise en place d'une IHM construite dynamiquement, l'utilisation d'une classe générant des données de tests durant le développement et les tests. Cette classe renvoie un flux aléatoire de données mais dont la structure est celle attendue. Cela permet de coder son IHM sans se soucier de la récupération de données et ainsi de se concentrer uniquement sur sa définition. Ce n'est pas nécessaire, c'est juste plus facile.

Dans l'exemple associé à cet article, la structure des données est la suivante :

Nom du champ Type de la donnée
Titre String
Description String
Messages List<Message>
FromWebPicture Drawable


Où l'objet Message est le suivant :

Titre String
Message String
From String
FromPicture Drawable


Le Format JSON est celui choisi pour cet exemple.

La méthode de construction d'un objet de ce type est la suivante :

private JSONObject generateOneData () {

try {

//Instanciation et déclaration de l'objet JSON.

JSONObject jsonPost = new JSONObject();

//Récupération d'un entier de référence (le choix du sujet du post).

int selectedInt = getRandomInt(6);

//Instanciation de ce sujet.

String subject = titres [ selectedInt ];

//Ajout du champ name avec la valeur post à l'objet JSON.

jsonPost .put( "name" , "post" );

//Ajout du champ titre avec la valeur subject à l'objet JSON.

jsonPost .put( "titre" , subject );

//Ajout du champ name avec la valeur post à l'objet JSON.

jsonPost .put( "description" , descriptions [ selectedInt ]);

//Ajout du champ FromWebPicture avec la valeur le nom de l'URL de l'image à l'objet JSON.

jsonPost .put( "fromWebPicture" , webDrawables [ selectedInt ]);

//Déclaration et instanciation d'un tableau JSON.

JSONArray jsonMessagesList = new JSONArray();

//Déclaration de l'objet JSON qui sera ajouté au tableau.

JSONObject jsonMessage ;

//entier permettant d'associer la même image au même champ « from » .

int fromNum ;

//Création en boucle des objets JSON à insérer dans le tableau.

for ( int i = 0; i < getRandomInt(9); i ++) {

//Instanciation de l'objet JSON, ajout de valeurs et ajout à la liste :

jsonMessage = new JSONObject();

jsonMessage .put( "name" , "message" );

jsonMessage .put( "titre" , titresMessages [getRandomInt(6)] + " " + subject );

jsonMessage .put( "message" , messages [getRandomInt(7)] + " " + subject );

fromNum =getRandomInt(4);

jsonMessage .put( "from" , from [ fromNum ]);

jsonMessage .put( "fromPicture" , drawables [ fromNum ]);

jsonMessagesList .put( jsonMessage );

}

//Ajout du tableau à l'objet JSON initial.

jsonPost .put( "messages" , jsonMessagesList );

//Et retour.

return jsonPost ;

} catch (JSONException e ) {

//Faire quelque chose d'intelligent ici :

return null ;

}


}

Où les tableaux suivants sont utilisés comme données de test (pour des raisons de lisibilité, je les ai vidés de leur contenu) :

/**

* 6 items Titres. Items utilisés lors de la génération des données.

*/

String[] titres = { "" };

/**

* 6 items Descriptions. Items utilisés lors de la génération des données.

*/

String[] descriptions = { "" };

/**

* 6 items titre du message. title Items utilisés lors de la génération des données.

*/

String[] titresMessages = { "" };

/**

* 7 items corps du message. Items utilisés lors de la génération des données.

*/

String[] messages = { "" };

/**

* 4 items auteur du message. Items utilisés lors de la génération des données.

*/

String[] from = { "" };

/**

* 4 items image de l'auteur. Items utilisés lors de la génération des données.

*/

String[] drawables = { "" };

/**

* 5 items image du sujet en provenance du web. Items utilisés lors de la génération des données.

*/

String[] webDrawables = { "" };

4. Android2EE: La Formation et l'Expertise Android à votre service

Image non disponible

Android2EE


Android2EE espère que cet article vous a été utile et profitable.
En tant qu'experts et formateurs sur le développement Android, nous serions heureux de vous accueillir à nos formations pour pouvoir continuer à vous expliquer l'art du développement Android (nous avons des tonnes de choses à vous raconter). Nous sommes persuadés qu'elles sont excellentes, les stagiaires qui les ont suivies le sont aussi.
Alors si vous souhaitez devenir un excellent développeur Android, il ne vous reste plus que deux choses à faire:

  • nous envoyer un mail à
  • convaincre votre service R.H. de l'importance de cette formation pour vous et pour l'entreprise.



Pour plus de renseignements, n'hésitez pas à cliquer sur les liens ci-dessous.



Comme AirFrance , Orange, Capgemini , Atos WorldLine et bien d'autres.
Vous aussi,
Bénéficiez des meilleures formations Android du moment



Android2EE est référencé en tant qu'organisme de formation, vous pouvez faire prendre en charge tout ou partie du montant de cette formation par votre OPCA. Les formations Android d'Android2EE sont éligibles au titre du DIF et CIF.

5. Récupération des tutoriels

Cet article est associé à un tutoriel que vous trouverez en libre téléchargement sur le site Android2ee. À l'adresse suivante : Page des tutoriels de la construction dynamique d'I.H.M. sur Android2ee

6. Articles, conférences et autres tutoriaux made in Android2EE

Vous pouvez trouver d'autres articles sur developpez.com rédigés par Android2EE.

Vous pouvez trouver les projets Android open sources d'Android2EE sur GitHub.

Android2EE sur Github

GDirectionsApiUtils pour vous simplifiez l'utilisation du service REST Google Api Direction (les itinéraires entre deux points).

Le MythicServiceHelper est un projet simplifiant la communication entre les services et les activités. Il est mieux d'utiliser, à l'heure d'aujourd'hui, EventBus ou Otto. Vous pouvez aller le voir quand même par curiosité.

Le Bluetooth avec Android expliqué. Ce projet est un chat bluetooth qui vous montre, par l'exemple, comment mettre en place une communication BlueTooth entre deux appareils Android.

Le projet ForecastYahooRest a pour objectif de vous expliquer comment mettre une architecture saine pour vos projets Android pour effectuer des appels REST. Ce projet est lié à la conférence "An Android Journey" que vous pouvez retrouver sur Android2ee.

Le projet SignInWithGoogleTutorialvous explique comment mettre l'authentification Google au sein de vos applications. Il est lié à la conférence Google Sign In que vous pouvez retrouver sur Android2EE.

Vous pouvez trouver les supports des conférences d'Android2EE sur SlideShared.

Android2EE sur SlideShare

Retrouvez la liste des tutoriaux Android2EE de la formation complète. C'est pas ma meilleure conférence :)

An Android Journey La conférence 2014 d'Android2EE qui vous donne toutes les astuces, les bonnes pratiques et les bons conseils à mettre en place dans vos applications pour en faire des applications exceptionnelles.

ActionBarCompat Cette conférence vous explique comment mettre en place l'ActionBar dans vos applications pour toutes les versions du système en utilisant l'ActionBarCompat.

GoogleSignIn L'authentification Google vous est expliquée dans cette conférence.

Android ProTips Cette conférence a été donnée à la DroidCon Paris 2013 pour vous présenter les meilleurs conseils sur le développement Android donnée aux GoogleIo. Ce sont mes bonnes pratiques favorites.

Architecture Android Une peu d'architecture, ça vous dit? Cette conférence est dédiée à l'architecture, quels sont les problèmes rencontrés et les bonnes pratiques à mettre en place.

Android, un nouveau futur s'ouvre à nous Cette conférence, donnée à Brazzaville, présente les enjeux de la mobilité et en particulier ma vision du futur relative à Android.

Combining the power of Eclipse with Android Cette conférence, donnée à l'EclipseDay 2012, présente comment utiliser la DDMS et chasser les fuites mémoires au sein de vos applications Android.

A Quick OverviewCette conférence, donnée au CocoHeads Toulouse en 2012, est une introduction à la programmation Android.

Android A Quick Course @DevoxxFr Cette présentation est un extraie de la conférence "Android A Quick Course", donnée à DevoxxFrance, pour apprendre le développement Android. Les vidéos (3 heures tout de même sont disponibles sur le site Android2EE ou sur Parleys)

Les vidéos de certaines de ces conférences sont disponibles à l'adresse suivante : Les vidéos


7. Le site Android2ee, une référence pour le développement Android.

Le site Android2EE vous propose des tutoriels, des articles, des vidéos, des conférences, des eBooks en libre consultation pour monter en compétence sur la technologie Android.

Vous trouverez tout cela dans la partie « Open Resources ».

N'hésitez plus visitez-le ! Android2EE

8. Android2ee vous présente l'Ebook de programmation Android

Le nouveau système d'exploitation de Google pour les téléphones portables et les nouvelles tablettes est là. Sa réputation est solide, il envahit le monde de la téléphonie, il est ouvert et offre des outils de développement Java au monde des programmeurs. Il ouvre les portes du développement mobile à tous les développeurs objets avec un coût minime pour la montée en compétence. Une seule question se pose :

Êtes-vous prêts ?

L'objectif de ces livres est très clair : vous permettre en un temps record d'être autonome en programmation Android. Si vous êtes un programmeur Java (débutant ou confirmé), le but est que vous soyez autonome en moins de dix jours. C'est cet objectif qui est à l'origine de ce livre, permettre aux collaborateurs de mon entreprise de monter en compétence sur cette technologie avec rapidité et efficience. Vous serez alors à même de concevoir une application, de l'implémenter, de la tester, de l'internationaliser et de la livrer à votre client.

Lancez-vous dans la programmation Android et faites-vous plaisir !

Vous serez aussi capable de connaître et comprendre quelles sont les considérations à avoir lorsque l'on a à charge une application Android en tant que professionnel de l'informatique. Quelle est la stratégie de tests à utiliser ? Comment signer son application ? Comment la déployer ? Comment mettre en place la gestion du cycle de vie de l'application ? Comment implémenter l'intégration continue ?

Soyez efficient dans l'encadrement de vos projets Android d'entreprise.


L'achat d'un EBook vous donne accès à l'ensemble des tutoriaux Android2EE, plus de 50 projets Android qui vous apprendrons à mettre en place une notion spécifique (SlidingDrawer, Parsing d'un service REST, Mise en place d'un service, d'un ContentProvider...). Vous pouvez dès maintenant vous lancer dans la programmation Android, n'hésitez pas faîtes vous plaisir, il y a 75% de réduction sur les EBooks en ce moment:

Apprendre la programmation Android avec les EBooks Android2EE

Android, A Complete Course, From Basics To Enterprise Edition (fr).

Android, A Quick Course (fr).

Android, An Entreprise Edition Vision (fr).

Les eBooks sont disponibles en français et en anglais, à votre convenance.


Nota Bene: L'ouvrage "Android, A Complete Course, From Basics To Enterprise Edition" réunit, au sein d'un même document, les livres "Android, A Quick Course" et "Android, An Enterprise Edition Vision" permettant au lecteur d'avoir dans un même document la totalité des préoccupations liées à la mise en place de projets Android, de la montée en compétence en tant que développeur à la gestion du cycle de vie du projet.

9. Remerciements

J'adresse ici tous mes remerciements à Djug pour son aide et ses déploiements et à ClaudeLELOUP pour l'excellence de ses corrections orthographiques. Un grand merci à Niitaku pour avoir corrigé la version 1.1 de cet article.

Je remercie les correcteurs techniques Feanorin et yan pour la pertinence de leurs remarques, la richesse de leur relecture et la découverte de la méthode removeAllViewsInLayout. Merci à vous deux.

Je remercie spécialement Monsieur Adam Daniel, DRH de développez.com, pour ses mails nocturnes, ses encouragements et son aide qui m'est précieuse.

Je remercie le site android2ee.com de me publier.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2011 Mathias Seguy. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.