The last update of Aptana Studio come with a new built-in Jetty-based HTTP server running on port 8000… the same as Django development server. There is no good way to disable the preview server feature of the popular editor, but our favorite web framework can be launched on another port. Just type python manage.py runserver 8080 instead of python manage.py and access to your work on http://localhost:8080.
Après avoir réalisé notre tout premier programme avec Google Android, nous allons nous lancer dans la réalisation d’un projet un peu plus complexe : un lecteur de flux RSS.
Ce sommaire lecteur de flux permettra juste de s’abonner, se désabonner et d’afficher des flux RSS. Vous pouvez récupérer l’archive incluant sources et binaires si vous souhaitez tester tout de suite le programme.
La plate-forme Android intègre le système de base de données relationnelle embarquée SQLite. SQLite est un mini SGBD ne nécessitant que peu de ressources, qui offre la possiblité de gérer facilement des bases de données de taille restreinte.
Comme son nom l’indique, SQLite s’utilise par le biais de requêtes SQL. Il est très bien intégré à Android, ce dernier propose un grand nombre de routines qui nous permettront d’interagir très simplement avec les données (par exemple, pour les afficher à l’écran). Nous l’utiliserons dans notre programme pour gérer la liste des flux RSS auxquels l’on est abonné.
Nous utiliserons un shéma assez simple pour notre base de donnée. Elle ne se constituera que deux trois colonnes :
| _id | url | visit |
|---|
Le champ _id est un nombre entier qui représente l’identifiant de chaque lien, il sera la clef primaire de notre table. Attention son nom est une convention Android / SQLite, veillez toujours à avoir une clef primaire nommée ainsi dans vos tables. Dans le cas contraire vous ne pourrez pas utiliser simplement les curseurs plus tard ! Ce champ est complètement géré par SQLite. Il s’occupera de l’incrémenter automatiquement et de veiller à sa cohérence.
Le champ url de type text contiendra l’adresse du flux RSS.
Le champ visit, qui n’a aucune utilisé dans l’état actuel du programme, pourrait servir à compter le nombre de chargement des flux RSS afin de les classer par ordre d’assiduité par la suite.
Nous allons placer tout ce qui a trait à la base de données dans une classe nommée Database. Après avoir créer un nouveau projet dans Eclipse, créez donc cette classe. Nous utiliserons deux variables qui portent sur tout la classe :
|
1 2 |
private SQLiteDatabase db; private RSSreader rss; |
db permet d’agir sur la base de donnée tandis que rss représente le contexte, notre classe principale (nommée RSSreader). La variable rss nous permet d’utiliser les fonctions openDatabase et createDatabase fournies par la plate-forme.
Le constructeur ce contente d’instancier la variable rss et de lancer la procédure d’ouverture de la base de données.
|
1 2 3 4 |
public Database (RSSreader rss) { this.rss = rss; open (); } |
Cette procédure appelle la méthode fournie par Android openDatabase qui nous permettra d’interagir avec la base de donnée depuis la variable db. Si la base de données n’existe pas, on appelle la procédure qui la créera.
|
1 2 3 4 5 6 7 8 9 10 |
private void open () { try { db = rss.openDatabase ("rssreader", null); } catch (FileNotFoundException e) { // Create the database createDb (); open (); } } |
La procédure de création de la base de donnée :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
private void createDb () { String sql; /* Command to view the DB : sqlite3 data/data/net.lapinblanc.android.rssreader/databases/rssreader */ try { // Create the database db = rss.createDatabase ("rssreader", 1, rss.MODE_PRIVATE, null); sql = "CREATE TABLE IF NOT EXISTS feed(_id INTEGER PRIMARY KEY, url TEXT, visit INTEGER);"; db.execSQL (sql); // Insert un example add ("//dunglas.fr/feed/"); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } |
La base de donnée est ici privée (MODE_PRIVATE), c’est à dire que seul notre programme pourra y accèder. La création en elle-même revient à envoyer une requête SQL classique de création de table. Nous créons donc notre base de donnée nommée rssreader puis nous insérons un flux d’exemple (celui de ce blog) en appelant la procédure add.
La base de donnée correspond en fait à un fichier texte rangé dans le répertoire /data/data/votre.package/databases/. Pour vous y connecter lancez la commande adb shell dans un terminal. Vous voici avec un shell au sein du système Android (celui de l’émulateur dans notre cas). Il s’agit en fait de BusyBox tournant au-dessus d’un noyau Linux. Pour utilisez la base de donnée en mode shell lancez sqlite3 /data/data/net.lapinblanc.android.rssreader/databases/rssreader. N’oubliez pas les points virgules terminaux à vos requêtes vous les exécuter !
La procédure add prend en paramètre une url et l’ajoute à la base de donnée :
|
1 2 3 4 5 6 |
public void add (String url) { /* Insert feed into the database */ SQLiteStatement st = db.compileStatement("INSERT INTO feed(url, visit) VALUES ('?, 0)"); st.bindString(1, url); st.execute(); } |
Ici aussi, le code est limpide, il s’agit de simples requêtes SQL comme si l’on agissait sur serveur de base de données classique.
Voyons maintenant comment supprimer un flux de la base de donnée :
|
1 2 3 4 5 6 |
public void delete (String url) { db.execSQL("DELETE FROM feed WHERE url='" + url + "';"); SQLiteStatement st = db.compileStatement("DELETE FROM feed WHERE url='?';")); st.bindString(1, url); st.execute(); } |
Dernière méthode, certainement la plus intéressante, celle qui renvoi la liste des flux dans la base de données :
|
1 2 3 4 5 6 |
public Cursor list () { /* Return a Cursor on a list of stored RSS feeds */ String [] selectionArgs = {}; String [] columns = {"_id", "url", "visit"}; return db.query (true, "feed", columns, null, selectionArgs, null, null, null); } |
Elle retourne un curseur, c’est ce curseur qui nous permettra plus tard de placer les flux dans une liste déroulante. Le tableau de chaines de caractères selectionArgs, ici vide, permet de spécifier des critères de sélection, formatés à la manière d’une clause WHERE dans une requête SQL. Le tableau columns permet d’indiquer quels colonnes nous souhaitons sélectionner, à la manière d’un SELECT en SQL. N’oubliez de sélectionner la colonne _id quelque soit votre requête. Sans elle l’utilisation ultérieur des curseurs sera beaucoup plus difficile.
Nous avons maintenant une base de donnée fonctionnelle et très légère sous Android. Dans le prochain article nous verrons comment créer une interface graphique pour gérer ces données.
Note : Merci à Infernal Quark d’avoir corrigé l’affreuse faille par injection SQL que j’avais laissé trainé…
Le kit de développement de Google Android désormais installé, commençons à coder ! L’objectif de cet article est de découvrir les bases de la programmation et de l’exécution de programmes pour Android. Il nécessite de maitriser la programmation en Java et de connaitre les rudiments du fonctionnement d’Eclipse.
Lançons Eclipse et créons un nouveau projet Android. Nous le nommerons Hello. Le package, dont le nom respectera les conventions Java, sera pour notre example net.lapinblanc.android.hello. Hello sera également l’Activity Name. L’Activity Name est simplement le nom de la classe principale du programme qui dérivera de la classe Activity d’Android. C’est simplement une classe exécutable. Application Name est le nom de votre application telle qu’elle apparaitra pour l’utilisateur.
Modifions maintenant notre programme pour lui faire afficher un texte de bienvenue. Il est nécessaire de créer une interface simpliste afin d’afficher quelque chose. Modifions la classe autogérée Hello pour qu’elle ressemble à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package net.lapinblanc.android.hello; import android.app.Activity; import android.os.Bundle; import android.widget.TextView; public class Hello extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); // On crée une boîte de texte TextView tv = new TextView(this); // On lui assigne le texte que l'on souhaite tv.setText ("Salut Android !"); // On affiche la boîte setContentView(tv); } } |
Android propose un grand nombre de “widgets”. Vous pourrez très simplement utiliser les classiques boutons, listes déroulantes, mais aussi des horloges, des sélecteurs de date et même des galerie photos et des afficheurs de vidéo !
Notre programme écrit, lançons-le depuis l’émulateur fourni. Il faudra créer une nouvelle configuration Eclipse. Cliquez sur la flèche verte et choisissez Open Run Dialog. Choisissez comme type Android Application, nommez votre application, indiquez le package et le même nom de projet que vous avez entrez un peu plus haut. C’est parti, l’émulateur doit se lancer et afficher notre magnifique programme.
Nous avons créé notre sommaire interface graphique entièrement dans le code source Java. Une approche plus moderne, popularisée par Glade, est de décrire l’interface graphique dans un fichier XML. Ce dernier sera lu par le programme et l’interface graphique sera automatiquement générée en conséquence. Il devient ainsi beaucoup plus facile de modifier et de faire évoluer une interface graphique déjà existante.
Android offre cette fonctionnalité par défaut.
Notre Hello World est cette fois-ci déjà généré par Eclipse !
Restaurons la classe par défaut :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package net.lapinblanc.android.hello; import android.app.Activity; import android.os.Bundle; public class Hello extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); } } |
Intéressons nous au fichier res/layout/main.xml, c’est dans celui-ci qu’est décrit notre interface. C’est l’attribut text de la balise TextView qui permet de spécifier ce qui sera affiché à l’écran.
Il existe plusieurs type de layouts, ils permettent d’agencer les objets à l’écran comme bon vous semble. Les principaux sont le LinearLayout, qui affiche les éléments de manière horizontale ou verticale, le RelativeLayout qui permet de placer les élements les uns par rapport aux autres (la boite de texte doit être à droite du bouton OK et en-dessous du label de bienvenu…), le TabularLayout qui agence les éléments de manière tabulaire ou encore le FrameLayout qui permet d’afficher plusieurs layouts au sein d’un seul. Pour de plus amples informations, référez-vous au tableau récapitulatif des différents layouts. Il est assez explicite.
Le fichier R.java, qu’il ne faut pas modifier, gère les liens entre le code source Java et le fichier XML de description d’interface.
Amusez-vous à modifier le fichier XML puis cliquez sur Run pour voir le résultat. Dans le prochain article nous attaquerons les choses sérieuses : nous commencerons enfin la réalisation de notre lecteur de flux RSS pour Android avec la partie base de donnée intégrée !
Cet article est le premier d’une série consacrée au développement d’applications sur la nouvelle plate-forme pour téléphones mobiles crée par Google : Android.
Les deux premiers billets seront très accessibles, voir simplistes. Celui-ci détaillera la procédure d’installation de l’environnement de développement (sur Mac OS X mais elle est très similaire sur Linux et Windows). Dans le prochain nous réaliserons le traditionnel “Hello Word” et nous présenterons les bases de la conception d’interface graphiques avec Android.
Nous passerons ensuite aux choses sérieuses avec la réalisation d’un lecteur de flux RSS en deux articles. D’abord l’utilisation de la base de donnée intégrée à Android (SQLite) puis la réalisation de l’interface graphique et la gestion des évènements (incluant formulaires, liste déroulantes et visualisation de pages internet).
Android est une plate-forme libre (principalement sous licence GPL v2 et Apache) qui contient un système d’exploitation basé sur Linux, une interface graphique, quelques applications et un kit de développement (SDK). Elle est promu par l’Open Handset Alliance, un consortium de compagnies du secteur du téléphone mobile dont sont membres LG, Motorola, Samsung, T-Mobile, Telefónica, Intel ou encore Texas Instruments. Les avantages mis-en-avant de la prochaine plate-forme maîtresse du secteurs sont:
Android utilise Java comme langage pour ses applications. Il utilise la machine virtuelle Dalvik, elle exécute des fichiers d’extension .DEX et permet une séparation entre les processus. Chaque application Android à son propre processus, il est donc possible de terminer une application sans devoir relancer le système entier.
Pas de panique, Google à bien fait les choses. Nous aurons besoin de deux éléments pour être opérationnels, le SDK en lui même et un plugin pour Eclipse.
Récupérez le SDK version Mac OS X sur la page dédiée du site d’Android. Décompressez le ensuite dans le répertoire de votre choix (pour ma part ça sera dans ~/). Le plus gros est fait ! Nous allons juste ajouter le dossier tools/ du SDK à notre PATH afin de pouvoir lancer facilement les utilitaires de la plate-forme depuis un terminal. Ouvrez ou créez le fichier ~/.bash_profile et ajoutez-y :
export PATH=${PATH}:<répertoire_de_votre_sdk>/tools
Vous remplacerez <répertoire_de_votre_sdk> par par le chemin du dossier que vous avez extrait.
Vous pouvez désormais lancer l’émulateur en double-cliquant sur emulator dans le répertoire tools/ ou simplement en tapant emulator dans le terminal (Applications -> Utilitaires -> Terminal).
Android est conçu pour qu’on y développe des applications avec l’IDE Eclipse d’IBM. Si ce n’est pas encore fait, téléchargez et installez-le. La version intitulée Eclipse IDE for Java Developers convient parfaitement.
Installons maintenant le plugin Android :
Lancez Eclipse et sélectionnez Help -> Software Updates -> Find and Install….
Dans la boîte de dialogue qui apparaît choisissez Search for new features to install puis appuyez sur Next.
Choisissez New Remote Site.
Dans la boîte qui s’affiche entrez Android Plugin comme nom et comme URL:
https://dl-ssl.google.com/android/eclipse/
Cliquez sur OK.
Le plugin doit apparaitre dans la liste, cliquez sur Finish.
Dans la boîte qui apparait cochez Android Plugin -> Developer Tools.
Cliquez sur Next.
Après avoir lu la license cliquez sur Accept puis sur Next, Finish et Install All.
Relancez maintenant Eclipse.
Il faut désormais configurer les préférences.Choisissez Eclipse -> Preferences puis Android.
Cliquez sur Browse… dans l’écran principal et indiquez le chemin de votre SDK.
Cliquez sur Apply puis sur OK.
Vous voici paré pour développer des applications Android depuis Mac OS X. La suite au prochaine épisode !
Note : Article librement inspiré et en parti du tutoriel officiel.