Android offre un système de communication trés ingénieux permettant de faire passer l’information entre Activitys ou plus généralement composants applicatifs . Ce système, déjà mentionné dans une partie précédente, est connu sous le nom d’Intent. Nous verrons donc dans cette partie comment transmettre l’information d’une Activity à une autre à l’aide de ce mécanisme d’Intents. Les lecteurs n’ayant toujours pas compris la différence subtile entre Activity et View seront probablement éclairé par la lecture des lignes suivantes.

Introduction

Android sandbox les applications. Le mot “sandbox” est un anglicisme qui signifie simplement “bac à sable”. Il vous paraît très probablement étrange de parler de “bac à sable” dans un problème d’informatique mais c’est pourtant bel et bien la traduction adéquate dans le contexte. Le sandboxing est une pratique de plus en plus courante dans la téléphonie mobile qui consiste à séparer presque totalement les applications entre elles. Lorsque Android exécute une application, il restreint cette dernière à des actions bien définies (accès mémoire, accès sur les capteurs, etc…). Cette pratique permet de protéger le système au maximum en évitant de laisser des applications faire comme bon leurs semble.

Malgré l’énorme apport sur la sécurité, le sandoxing restreint fortement la communication entre applications. C’est dans l’optique de contourner ce “problème”, que les Intents ont été conçus. Pour faire simple, un Intent est un ensemble de données qui peut être passé à un autre composant applicatif (de la même application ou non) de façon implicite (requête pour une action – lire de la musique ou scanner un code barre par exemple) ou explicite (lancement d’une classe précise).

Le développement sur iPhone suit également cette règle de “sandboxing”. Malheureusement le système de communication entre application appelé “URL scheme” est beaucoup moins évolutif et permissif. Ce dernier consiste simplement à enregistrer l’application auprès du système qui laissera alors les applications démarrer l’application pour une URI (sous Safari par exemple). Cela montre très clairement l’avantage d’Android sur l’iPhone en matière de communication entre composants applicatifs. De plus, ce qui est faisable avec l’iPhone l’est très souvent sous Android – et inversement.

Démarrage d’une Activity grâce aux Intents

Pour bien décrire le système des Intents, nous allons créer une petite application (sans aucun but réel, je l’accorde) composée de 2 écrans : le premier dispose d’un bouton permettant de démarrer une nouvelle Activity de façon explicite. La seconde Activity affichera simplement un champ de recherche permettant d’effectuer une recherche sur Google. Le code de cette application est disponible dans ce dossier zippé.

Démarrage d’une activité de façon explicite

Pour commencer, créons une première Activity qui affichera un unique bouton central. Le code XML ci-dessous est composé d’une unique balise Button. Cette simplicité de l’interface graphique provient du fait que l’espace disponible au développeur pour afficher son application (l’intégralité de l’écran moins la barre de tâches et la barre de nom) est disponible sous la forme d’un FrameLayout. L’image ci-dessous montre la hiérarchie des vues générées avec ce fichier XML. On aperçoit facilement (en bleu) un FrameLayout.

Les paramètres android:layout_gravity="center" et android:text="Cliquez ici pour démarrer" permettent respectivement de centrer le bouton dans sa vue parente et de définir le texte du bouton.

<?xml version="1.0" encoding="utf-8"?>
<Button
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:id="@+id/button"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:layout_gravity="center"
	android:text="Cliquez ici pour démarrer" />

Notre interface graphique étant prête, il suffit maintenant de créer notre première Activity. Pour faciliter la compréhension, j’ai préféré directement commenter le code. N’oubliez pas d’inclure cette nouvelle Activity dans le fichier Manifest.xml pour qu’Android autorise son exécution.

package com.cyrilmottier.android.tutorial4;
 
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
 
/*
 * La classe EntryPoint implémente l'interface View.OnClickListener. Cela permet ainsi
 * d'enregistrer l'activité auprès des vues pour qu'elle puiise recevoir les évènements de "clic".
 */
public class EntryPoint extends Activity implements View.OnClickListener {
 
	/*
	 * Cette variable permettra de conserver une référence sur le bouton
	 * de l'interface
	 */
	private Button mButton;
 
	/*
	 * La redéfinition de la méthode onCreate(Bundle) permet d'effectuer des actions
	 * supplémentaires à l'Activity de base.
	 */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        /*
         * On créé l'interface graphique en utilisant le fichier entry.xml.
         * Ce dernier étant disponible comme ressource (dans /res/layout), il suffit d'utiliser
         * le fichier R.java et sa sous-classe layout.
         */
        setContentView(R.layout.entry);
        /*
         * Récupère une référence sur le bouton en utilisant son identifiant
         */
        mButton = (Button)findViewById(R.id.button);
        /*
         * On enregistre l'activité auprès du bouton pour recevoir les évènements
         * "clic" provoqué par l'utilisateur.
         */
        mButton.setOnClickListener(this);
    }
 
    /*
     * La méthode onClick(View) provient de l'interface View.OnClickListener.
     */
	@Override
	public void onClick(View v) {
		if (v == mButton) {
			/*
			 * Nous sommes maintenant sûr que la vue ayant été cliquée est le bouton
			 * de notre interface. Il suffit donc de créer un nouvel Intent pour démarrer
			 * la seconde activité.
			 */
			Intent intent = new Intent(EntryPoint.this, GoogleSearch.class);
			startActivity(intent);
		}
	}
}

Notre première Activity est maintenant terminée. Le lancement d’une nouvelle Activity de façon explicite s’effectue en deux lignes. La première, Intent intent = new Intent(EntryPoint.this, GoogleSearch.class); crée simplement un nouvel Intent dont le contexte de départ est l’Activity courante (EntryPoint.this) et l’Activity de destination se nomme GoogleSearch.

Démarrage d’une activité de façon implicite

Il ne nous reste maintenant plus qu’à définir l’Activity GoogleSearch en utilisant des principes similaires à ceux précédemment décrits. Commençons, tout d’abord par créer l’interface graphique :

<?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="wrap_content"
	android:layout_gravity="center"
	android:padding="10px">
 
	<TextView
		android:text="Entrez la recherche à effectuer dans le champ ci-dessous puis cliquez sur le bouton"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:layout_marginBottom="10px"
		android:gravity="center_horizontal" />
 
	<EditText
		android:id="@+id/editText"
		android:layout_marginBottom="5px"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content" />
 
	<ImageButton
		android:id="@+id/imageButton"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:src="@drawable/logo_google"
		android:layout_gravity="center"></ImageButton>
 
</LinearLayout>

Il ne me semble pas très important de décrire le fichier XML précédent car il peut être considéré comme classique. Il est à noter, tout de même, une légère différence avec les fichiers XML de notre HelloWorld : les ressources de type chaines de caractères, dimensions, etc. ne sont pas externalisés dans un fichier externe. Dans notre cas cela n’a pas réellement d’impact puisque nous n’allons pas internationaliser l’application.

package com.cyrilmottier.android.tutorial4;
 
import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.ImageButton;
 
public class GoogleSearch extends Activity implements View.OnClickListener {
 
	private ImageButton mImageButton;
	private EditText mEditText;
 
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.google);
		mImageButton = (ImageButton)findViewById(R.id.imageButton);
		mEditText = (EditText)findViewById(R.id.editText);
		mImageButton.setOnClickListener(this);
	}
 
	@Override
	public void onClick(View view) {
		if (view == mImageButton) {
			final String requete = "http://www.google.fr/search?q=" + mEditText.getText();
			Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(requete));
			startActivity(intent);
		}
	}
}

Un clic sur le bouton “Google” créé un nouvel Intent à l’aide du constructeur Intent(String,Uri). La chaine de caractère passée en paramètre est une action à effectuer (ici ACTION_VIEW : action définie par le framework qui consiste à démarrer un navigateur web sur l’Uri donnée). On démarre enfin l’activité par un simple startActivity(Intent). Une action ne définissant pas une application en particulier, Android va tenter de chercher une application s’étant définie comme capable de répondre à l’action ACTION_VIEW. C’est cette “non certitude” sur l’application à ouvrir qui explique le nom de cette méthode : implicite. Généralement le navigateur utilisé est celui inclus de base dans le téléphone.

Conclusion

Les Intents sont des composants essentiels de l’architecture Android. Le démarrage explicite ou implicite d’une Activity à l’aide d’Intents n’est qu’une petite infime partie des possibilités de ce mécanisme. Cette partie fait donc office d’introduction aux Intents et vous permet de mieux comprendre la communication entre composants applicatifs Android. Vous êtes maintenant prêts à coder vos premiers programmes à écrans multiples !

Pour aller plus loin :

• Tutoriel : Les composants principaux d'Android
• Tutoriel : Changer la skin de l'émulateur Android
• Tutoriel : Installation du SDK Android
• Android SDK 2.1 disponible !
• Nouvelle mise à jour pour le SDK Android

Tutoriel Android : Introduction aux Intents - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Formation vidéo : Devenez un développeur Android

L’ami Nix et son compère Manu, qui ont déjà un certain nombre d’applications Android à succès à leur actif (on leur doit aussi le site AndroLib), nous ont concocté une superbe formation vidéo pour vous apprendre les bases de la programmation Android.

Cette formation est destinée aux développeurs qui veulent se mettre à Android rapidement, mais aussi à ceux qui aimeraient utiliser Android pour se forger une première expérience dans la programmation (mais attention, il ne s’agit pas d’un cours de programmation).

Voici la table des matières, où chaque partie correspond à une vidéo, pour un total de plus de 8 heures de formation !

Prise en main

• Présentation d’Android
• Téléchargement d’Eclipse et du SDK Android
• Installation d’Eclipse et présentation de l’IDE
• Création et utilisation de l’émulateur
• Changer l’apparence de l’émulateur
• Première application Android
• Perspective et DDMS
• Le LogCat
• Le Débuggeur
• Installation du pilote USB
• Faire une capture d’écran
• Importer un projet
• Android Debug Bridge (ADB)
• Communiquer avec l’émulateur
• Aide Dynamique
• Paramétrer le téléphone

Vue d’ensemble

• Introduction aux activités
• Introduction aux sous-activités
• Introduction aux menus
• Introduction aux menus contextuels
• Les notifications
• Ouvrir des activités du système
• Les BroadcastReceiver et Alarmes

Création d’une application avec UI

• Les Layouts
• Les vues
• Boîte de dialogue
• Les toasts
• Le manifest.xml
• Animations de contrôle
• Internationalisation
• List view

Réseau et Internet

• Télécharger une page web (getHttp)
• Socket
• Les SMS
• Envoyer un email et/ou SMS
• Géolocalisation avec Google Map API
• Simuler une panne réseau

Accès aux données

• Les Adapters
• Ressources
• Les fichiers
• Base de données SQLite
• Gestion des préférences
• Accéder à la liste de contacts

Multimédia

• Sound
• Dessin et SurfaceView
• Télécharger une image depuis le web
• Lire une vidéo
• Reconnaissance vocale
• OpenGL

Utiliser le hardware

• TouchScreen
• Camera
• Utiliser les capteurs
• Vibration
• Le micro et Playback
• Le Wifi

Aller plus loin dans le développement

• Thread
• Les services
• Créer une AppWidget
• Récupérer les informations du téléphone
• Récupérer et changer le fond d’écran
• Lancer des commandes du Shell Linux
• Activer et désactiver le GPS

Trucs et astuces

• Présentation et utilisation du Code QR
• Forcer une application à se fermer
• Astuces pour l’émulateur
• Le Garbage Collector System.gc
• Lister et lancer les applications installées
• Décompiler et re-signer un fichier APK
• Montrer les exemples du SDK

Publier une application dans le Market

• Présentation du Market
• Publier une application dans le Market
• Mettre à jour une application dans le Market
• AndroLib

Android est la plateforme mobile du futur, et cette formation est le moyen idéal pour vous y mettre pour seulement 39.95 euros ! Et croyez-moi, la qualité est au rendez-vous !

On vous donne rendez-vous pour l’Android Developer Challenge 3?

Formation vidéo : Devenez un développeur Android

Edit : Il est possible de télécharger les vidéos ainsi que les fichiers sources des tutoriaux qui sont traités.

Articles au hasard :

• HTC Bigfoot, successeur du HTC G1?
• Le Motorola Droid booste les téléchargements sur l’Android Market
• Acer A1 avec Android disponible… en précommande
• Le Motorola Zeppelin nous tourne le dos
• Samsung va mettre à jour ses terminaux Android

Devenez développeur Android : Formation vidéo - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Mon premier tutoriel présentait les bases d’une application Android et Google Maps élémentaire.

Ce deuxième tutoriel va présenter les notions de map overlay, de géolocalisation et de client http. Pour cela nous présenterons une solution de recherche de services basées sur Yahoo Search API et par la même occasion cela donnera un exemple d’utilisation de REST API avec Android.

NB : Yahoo Search ne fonctionne qu’aux US pour l’instant, placez donc votre emulateur au dessus des US avec un geo fix approprié.

La license de Yahoo Search ne permet pas son utilisation a des fins commerciales.

Dans un prochain tutoriel nous utiliserons Google Search et n’aurons pas ces limitations.

Pour la réalisation du client REST (Representational State Transfer) nous utiliserons la librairie HttpClient. Dans GLocation j’utilisais android.net.http.RequestQueue mais cette API, bien que toujours utilisée en interne par Android, n’est plus publique. Pour la recherche de services j’utilisais une solution un peu complexe faisant appel a Google Search, mais les restrictions de droits d’usage en interdisent plus ou moins l’usage aujourd’hui..

Maps Overlay avec Android SDK 1.5

Apres avoir essayé le nouvel Overlay proposé dans la librairie MyLocationOverlay je l’ai abandonné faute de pouvoir gérer la fréquence de rafraîchissement et donc de pouvoir limiter l’usage du GPS. J’ai ensuite essayé de faire un custom Overlay pour enfin choisir l’ItemizedOverlay qui correspond bien pour gérer les résultats de la recherche.

Description de l’Itemized Overlay

L’ItemizedOverlay est un Overlay qui permet d’ajouter des OverlayItems et ensuite de les sélectionner.

Nous allons d’abord créer une classe Placemark, extension de la class OverlayItem qui définissent les Items contenus dans l’Overlay.

Chaque Object Placemark contiendra les informations de chaque point résultant de la recherche avec des accesseurs pour les extraire si nécessaire.

Cela permettra de récuperer toutes les propriétes venant des résultats des recherches et des les transmettre avec la position, le titre, la description a l’overlay en une fois.

Placemark.java :

package org.example.android.apis;
 
import android.os.Bundle;
 
import com.google.android.maps.GeoPoint;
import com.google.android.maps.OverlayItem;
import com.google.map.MapPoint;
 
/**
* Placemark Object containing
* all informations about our search results
* Definition des parametres :
* http://developer.yahoo.com/search/local/V3/localSearch.html
*
* @author Andre Charles Legendre
*
*/
 
public class Placemark extends OverlayItem {
String mTitle;
String mSnippet;
GeoPoint mPoint;
 
private Bundle placeBundle;
 
public Placemark(GeoPoint point, String title, String snippet,
Bundle placeBundle) {
super(point, title, snippet);
this.placeBundle = placeBundle;
this.mTitle = title;
this.mSnippet = snippet;
this.mPoint = point;
}
 
public Bundle getBundle() {
return this.placeBundle;
}
 
public String getid() {
return placeBundle.getString("id");
}
 
public String getAddress() {
return placeBundle.getString("Address");
}
 
public String getCity() {
return placeBundle.getString("City");
}
 
public String getState() {
return placeBundle.getString("State");
}
 
public String getPhone() {
return placeBundle.getString("Phone");
}
 
public String getLatitude() {
return placeBundle.getString("Latitude");
}
 
public String getLongitude() {
return placeBundle.getString("Longitude");
}
 
public String getRating() {
return placeBundle.getString("Rating");
}
 
public String getAverageRating() {
return placeBundle.getString("AverageRating");
}
 
public String getTotalRatings() {
return placeBundle.getString("TotalRatings");
}
 
public String getTotalReviews() {
return placeBundle.getString("TotalReviews");
}
 
public String getLastReviewDate() {
return placeBundle.getString("ReviewDate");
}
 
public String getLastReviewIntro() {
return placeBundle.getString("ReviewIntro");
}
 
public String getDistance() {
return placeBundle.getString("Distance");
}
 
public String getUrl() {
return placeBundle.getString("Url");
}
 
public String getClickUrl() {
return placeBundle.getString("ClickUrl");
}
 
public String getMapUrl() {
return placeBundle.getString("MapUrl");
}
 
public String getBusinessUrl() {
return placeBundle.getString("BusinessUrl");
}
 
public String getBusinessClickUrl() {
return placeBundle.getString("BusinessClickUrl");
}
 
public Bundle getCategories() {
return placeBundle.getBundle("Categories");
}
 
public MapPoint getLocation() {
return new MapPoint(Integer.decode(placeBundle.
getString("Latitude")),Integer.decode(placeBundle.
getString("Longitude")));
}
 
public String toString() {
return (placeBundle.toString());
}
}

Nous allons ensuite créer une classe MapDemoOverlay qui étend ItemizedOverlay.

Les markers des Items sont affichés automatiquement par la classe ItemizedOverlay, pour ce faire on les passe en paramètre à la création de l’Overlay.

La methode clé de cette classe est la methode draw. La methode draw n’a besoin d’afficher que ce qui concerne les titres et autres Toasts ou InfoWindows.

Une des différence majeure concernant la methode draw en 1.5 est l’utilisation de l’objet Projection pour trouver les coordonnées écran à partir des coordonnées geographiques.

La méthode onTap est très simple du fait que onTap de ItemizedOverlay recupère directement l’index de l’item selectionné.

De ce fait en utilisant l’index onTap peut directement récupérer un objet Placemark et ainsi toutes les infos fournis par Yahoo Search.

Place au code pour plus de clarté :

/**
* This method is they key element of our map application
* ...
*/
protected class MapDemoOverlay extends ItemizedOverlay<OverlayItem> {
private List<OverlayItem> items = new ArrayList<OverlayItem>();
 
public MapDemoOverlay(Drawable marker) {
super(boundCenterBottom(marker));
populate();
}
 
private Paint innerPaint, borderPaint, textPaint;
 
@Override
public boolean onTap(int index) {
Placemark placeMark = (Placemark) myLocationOverlay.getItem(index);
Log.e("MapViewDemo", "ONTAP index : " + index + " place : "
+ placeMark.getTitle());
return super.onTap(index);
}
 
@Override
public void draw(Canvas canvas, MapView myMapView, boolean shadow) {
super.draw(canvas, myMapView, shadow);
// Log.e("MapViewDemo", "MapDemoOverlay...draw");
// Setup our "brush"/"pencil"/ whatever...
Paint paint = new Paint();
paint.setTextSize(12);
 
// Create a Point that represents our GPS-Location
Double lat = MapViewDemo.this.myLocation.getLatitude() * 1E6;
Double lng = MapViewDemo.this.myLocation.getLongitude() * 1E6;
GeoPoint geoPoint = new GeoPoint(lat.intValue(), lng.intValue());
Projection myprojection = myMapView.getProjection();
Point point = new Point();
myprojection.toPixels(geoPoint, point);
// Setup a color for our location
paint.setStyle(Style.STROKE);
paint.setARGB(255, 80, 150, 30); // Nice strong Android-Green
// Draw our name
canvas.drawText(getString(R.string.map_overlay_own_name),
point.x + 9, point.y, paint);
paint.setStrokeWidth(1);
paint.setARGB(255, 0, 0, 0);
canvas.drawCircle(point.x, point.y, 7, paint);
// Log.e("MapViewDemo", "MapDemoOverlay...draw
paint.setStyle(Style.FILL);
drawInfoWindow(canvas, myprojection, shadow);
ArrayList<Placemark> placeMarks = MapViewDemo.this.getSearch();
Placemark placeMark;
if (placeMarks != null)
synchronized (placeMarks) {
for (int it = 0; it < placeMarks.size(); it++) {
placeMark = (Placemark) placeMarks.get(it);
geoPoint = placeMark.getPoint();
myprojection.toPixels(geoPoint, point);
canvas.drawText(placeMark.getTitle(), point.x + 9,
point.y, paint);
}
}
}
 
public void addItem(OverlayItem item) {
items.add(item);
populate();
}
 
@Override
protected OverlayItem createItem(int index) {
return (OverlayItem) items.get(index);
}
 
@Override
public int size() {
return items.size();
}
 
private void drawInfoWindow(Canvas canvas, Projection myprojection,
boolean shadow) {
 
if (MapViewDemo.this.selectedSearchPoint != null) {
GeoPoint geoPoint = MapViewDemo.this.selectedSearchPoint
.getPoint();
Point point = new Point();
myprojection.toPixels(geoPoint, point);
 
// Setup the info window with the right size & location
int INFO_WINDOW_WIDTH = 150;
int INFO_WINDOW_HEIGHT = 30;
RectF infoWindowRect = new RectF(0, 0, INFO_WINDOW_WIDTH,
INFO_WINDOW_HEIGHT);
int infoWindowOffsetX = point.x - INFO_WINDOW_WIDTH / 2;
int infoWindowOffsetY = point.y - INFO_WINDOW_HEIGHT
- bubbleIcon.getHeight();
infoWindowRect.offset(infoWindowOffsetX, infoWindowOffsetY);
 
// Draw inner info window
canvas.drawRoundRect(infoWindowRect, 5, 5, getInnerPaint());
// Draw border for info window
canvas.drawRoundRect(infoWindowRect, 5, 5, getBorderPaint());
// Draw the MapLocation's name
int TEXT_OFFSET_X = 10;
int TEXT_OFFSET_Y = 15;
Log.e("Glocation", " selectedSearchPoint5 "
+ MapViewDemo.this.selectedSearchPoint);
canvas.drawText(MapViewDemo.this.selectedSearchPoint
.getSnippet(), infoWindowOffsetX + TEXT_OFFSET_X,
infoWindowOffsetY + TEXT_OFFSET_Y, getTextPaint());
}
}
 
public Paint getInnerPaint() {
if (innerPaint == null) {
innerPaint = new Paint();
innerPaint.setARGB(225, 75, 75, 75); // gray
innerPaint.setAntiAlias(true);
}
return innerPaint;
}
 
public Paint getBorderPaint() {
if (borderPaint == null) {
borderPaint = new Paint();
borderPaint.setARGB(255, 255, 255, 255);
borderPaint.setAntiAlias(true);
borderPaint.setStyle(Style.STROKE);
borderPaint.setStrokeWidth(2);
}
return borderPaint;
}
 
public Paint getTextPaint() {
if (textPaint == null) {
textPaint = new Paint();
textPaint.setARGB(255, 255, 255, 255);
textPaint.setAntiAlias(true);
}
return textPaint;
}
}

Détection des changements de sélection

Lors de la description de la class MapDemoOverlay nous avons présenté la method onTap retournant le numéro de l’item sélectionné.

Cette méthode ne permet pas de détecter facilement les changements de sélection.

Pour le faire nous allons ajouter à notre Overlay un listener ItemizedOverlay.OnFocusChangeListener .

Ce listener est affecté à notre Overlay par l’appel :

myLocationOverlay.setOnFocusChangeListener(FOCUS_LISTENER); où FOCUS_LISTENER est notre OnFocusChangeListener.

Dans notre cas précis le listener tiendra à jour MapViewDemo.this.selectedSearchText utilisé par draw pour afficher le contenu de infoWindow donnant des informations au sujet de l’item sélectionné par l’utilisateur.

ItemizedOverlay.OnFocusChangeListener FOCUS_LISTENER = new ItemizedOverlay.OnFocusChangeListener() {
public void onFocusChanged(ItemizedOverlay overlay, OverlayItem newFocus) {
if (newFocus != null) {
Log.e("MapViewDemo", "MapViewDemo ChangeFocus "
+ newFocus.getTitle());
}
MapViewDemo.this.selectedSearchPoint = (Placemark) newFocus;
}
};
}

Description de la gestion de la géolocalisation

En utilisant la géolocalisation nous pouvons obtenir notre position immédiate.

Nous pouvons aussi créer un LocationListener en charge de gérer nos changements de position.

Pour simplifier le code nous avons groupé cela dans une méthode initMyLocation() appellée au démarrage, dans la méthode onCreate.

initMyLocation affiche d’abord notre position courante en appelant myLocationManager.getLastKnownLocation et initialise le rafraîchissement de notre position quand on se deplace en créant un LocationListener et en le passant en paramètre a this.myLocationManager.requestLocationUpdates.

Cette solution nous permet de configurer la fréquence des mises à jour de notre position à l’aide des 2 paramètres :

MINIMUM_TIME_BETWEEN_UPDATE, MINIMUM_DISTANCECHANGE_FOR_UPDATE

initMyLocation initialise aussi l’overlay dans lequel seront affichés notre geolocalisation et les résultats de nos recherches :

/**
* Initialises the MyLocationOverlay and adds it to the overlays of the map
* Prepare the things, that will give us the ability, to receive
* Information about our GPS-Position.
*/
private void initMyLocation() {
myLocationOverlay = new MapDemoOverlay(marker);
myLocationOverlay.setOnFocusChangeListener(FOCUS_LISTENER);
myMapView.getOverlays().add(myLocationOverlay);
this.myLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
this.myLocation = myLocationManager.getLastKnownLocation("gps");
Double lat = this.myLocation.getLatitude() * 1E6;
Double lng = this.myLocation.getLongitude() * 1E6;
GeoPoint geoPoint = new GeoPoint(lat.intValue(), lng.intValue());
this.myMapController.setCenter(geoPoint);
this.myMapController.setZoom(11);
myMapView.setClickable(true);
myMapView.setEnabled(true);
/*
* Register with out LocationManager to send us an intent (whos
* Action-String we defined above) when an intent to the location
* manager, that we want to get informed on changes to our own position.
*/
locListener = new LocationListener() {
 
public void onLocationChanged(Location newLocation) {
if (System.currentTimeMillis() > MapViewDemo.this.endTime) {
MapViewDemo.this.endTime = System.currentTimeMillis()
+ MINIMUM_TIME_BETWEEN_UPDATE_LIST;
}
if (MapViewDemo.this.doUpdates)
MapViewDemo.this.updateView(newLocation);
}
 
public void onProviderDisabled(String provider) {
}
 
public void onProviderEnabled(String provider) {
}

Utilisation de HttpClient pour appeler Yahoo Search

La version du code est une version simpliste où l’application attend la réponse et son formattage.

Une version utilisable en production supposerait de créer un thread pour gérer ces traitements en background.

J’ai préféré simplifier pour garder la lisibilité.

Android propose deux libraries pour les connection http (3 si on compte les sockets).

La premiere est android.net et la second org.apache.http.client.HttpClient .

J’utilise cette dernière car j’ai déjà eu a l’utiliser par ailleurs et que c’est un outil très stable et  efficace.

Pour faciliter la réutilisation de ce code j’ai créé un objet MapDemoConnection en charge de gérer la connection http avec le service Yahoo Search.

Cet objet construit l’addresse url, l’appelle, recupère les données et lance le parsing.

MapDemoConnection.java :

package org.example.android.apis;import java.io.IOException;
 
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.List;
 
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.xml.sax.SAXException;
 
import android.util.Log;
import android.util.Xml;
 
/**
* MapDemoConnection sends http requests to the web service.
*
* @author Andre Charles Legendre
*
*/
 
public class MapDemoConnection {
 
private static String USER_AGENT = "Mozilla/4.5";
private static String TAG = "MapDemoConnection";
 
private String password;
private String serverUrl;
 
public MapDemoConnection(String serverUrl, String username, String password) {
this.serverUrl = serverUrl;
this.password = password;
}
 
/**
* Call Service and parse results
*
* @param resource
*            String containing text you want to search with
* @param resourceType
*            String GET or POST
* @param httpParams
*            List<NameValuePair> List of parameters send to the service
* @param myContentHandler
*            MyContentHandler Object in charge to parse the result
* @return ArrayList<Placemark> containing List of PlaceMark one for each
*         result of the search
*/
 
public ArrayList<Placemark> parse(String resource, String resourceType,
List<NameValuePair> httpParams, MyContentHandler myContentHandler) {
if (resource.length() > 140) {
throw new IllegalArgumentException(
"Search text is longer than 140 characters");
}
String xml = null;
try {
if (resourceType.equals("GET")) {
xml = getRequest(resource);
} else {
xml = postRequest(resource,
new UrlEncodedFormEntity(httpParams));
}
} catch (SocketTimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (xml != null) {
try {
Log.e("MyEventHandler", "xml=" + xml);
Xml.parse(xml, myContentHandler);
} catch (SAXException e) {
Log.e("MyEventHandler", "xml=" + xml + "ERROR=" + e.toString());
}
return myContentHandler.parse();
}
return null;
}
 
/**
* Sends a GET request to web service
*
* @param resource
* @return String response from the server
*/
private String getRequest(String resource) {
String result = null;
String url = serverUrl + resource;
Log.d(TAG, "GET: " + url);
 
HttpClient client = new DefaultHttpClient(new BasicHttpParams());
HttpGet getMethod = new HttpGet((url));
try {
getMethod.setHeader("User-Agent", USER_AGENT);
getMethod.addHeader("Authorization", "Basic " + getCredentials());
 
HttpResponse httpResponse = client.execute(getMethod);
result = retrieveInputStream(httpResponse.getEntity());
 
} catch (Exception e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
} finally {
getMethod.abort();
}
Log.e(TAG, result);
return result;
}
 
/**
* Sends a POST request
*
* @param resource
* @param formParams
*            UrlEncodedFormEntity which is comprised of a List of
*            NameValuePairs
* @return String response from the server
* @throws SocketTimeoutException
*             , SocketException
*/
private String postRequest(String resource, UrlEncodedFormEntity formParams)
throws SocketTimeoutException, SocketException {
String result = null;
String url = serverUrl + resource;
Log.d(TAG, "POST: " + url);
 
HttpClient client = new DefaultHttpClient(new BasicHttpParams());
HttpPost postMethod = new HttpPost((url));
try {
// postMethod.setHeader("User-Agent", USER_AGENT);
// postMethod.addHeader("Authorization", "Basic " +
// getCredentials());
 
if (formParams != null)
postMethod.setEntity(formParams);
 
HttpResponse httpResponse = client.execute(postMethod);
result = EntityUtils.toString(httpResponse.getEntity());
 
if (result != null)
Log.d(TAG, "Returned response [" + httpResponse.getStatusLine()
+ "] from the server: " + result);
 
} catch (Exception e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
} finally {
postMethod.abort();
}
return result;
}
 
/**
* Retrieves the content input stream from a GET request
*
* @param httpEntity
* @return String service response
*/
private String retrieveInputStream(final HttpEntity httpEntity) {
int length = (int) httpEntity.getContentLength();
StringBuffer stringBuffer = new StringBuffer(length);
try {
InputStreamReader inputStreamReader = new InputStreamReader(
httpEntity.getContent(), HTTP.UTF_8);
char buffer[] = new char[length];
int count;
 
while ((count = inputStreamReader.read(buffer, 0, length - 1)) > 0) {
stringBuffer.append(buffer, 0, count);
}
} catch (UnsupportedEncodingException e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
} catch (IllegalStateException e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
} catch (IOException e) {
Log.e(TAG, e.getMessage());
e.printStackTrace();
}
return stringBuffer.toString();
}
 
/**
* Retrieves the credentials
*
* @return String password
*/
private String getCredentials() {
return password;
// return new String(Base64.encode((username + ":" +
// password).getBytes()));
}
}

Parsing des données reçues de Yahoo Search

Pour le parsing nous allons créer un object MyContentHandler en charge de mettre en forme les données reçues.

Ces données reçues seront mises dans un ArrayList d’objects PlaceMark.

La fonction draw de l’ItemizedOveraly sera en charge d’afficher ces PlaceMark et de gérer leur interactivité.

Nous utilisons le package de org.xml.sax pour le parsing.

MyContentHandler extends DefaultHandler et doit donc implémenter toutes les méthodes startElement, endElement, etc.

En fait MapDemoConnection lance le parsing en appelant Xml.parse(xml, myContentHandler) où le paramètre xml contient les données reçues et où myContentHandler est l’objet en charge de les parser.

Lors du parsing myContentHandler appelle les méthodes startElement, endElement, etc. quand il reçoit une notification à chaque étape de la lecture du document.

MyContentHandler

package org.example.android.apis;import java.util.ArrayList;
 
import java.util.Iterator;
import java.util.Set;
 
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
import com.google.android.maps.GeoPoint;
 
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
 
/**
* MapViewDemo is the Map Activity of our application
*
* @author Andre Charles Legendre
*
*/
 
public class MyContentHandler extends DefaultHandler {
StringBuilder elementBuilder = null;
private String id;
private int numCat;
private Bundle bundle;
private Bundle categories;
private Bundle bundles;
private String title;
private String snippet;
 
public MyContentHandler(Activity activity) {
}
 
public ArrayList<Placemark> parse() {
return getPlaceMarks(this.bundles);
}
 
@Override
public void startDocument() throws SAXException {
// Log.e("MapDemoMYCONTENTHANDLER", "STARTDOCUMENT");
this.bundles = new Bundle();
}
 
public void endDocument() throws SAXException {
Log.e("MapDemoMYCONTENTHANDLER", "Finish");
}
 
@Override
public void startElement(String namespaceURI, String localName,
String qName, Attributes atts) throws SAXException {
// Log.e("MapDemoMYCONTENTHANDLER", "STARTELEMENT " + localName);
elementBuilder = new StringBuilder();
if (localName.equals("Categories")) {
this.numCat = 0;
categories = new Bundle();
} else if (localName.equals("Result")) {
id = atts.getValue("id");
bundle = new Bundle();
}
}
 
@Override
public void endElement(String namespaceURI, String localName, String qName)
throws SAXException {
String text = elementBuilder.toString();
//Log.e("MapDemoMYCONTENTHANDLER", "ENDELEMENT " + localName + " : "
//            + text);
if (localName.equals("ResultSetMapUrl")) {
} else if (localName.equals("Result")) {
bundles.putBundle(id, bundle);
} else if (localName.equals("Categories")) {
bundle.putBundle(id, categories);
} else if (localName.equals("Category")) {
categories.putString("" + numCat, text);
} else {
bundle.putString(localName, text);
}
}
 
@Override
public void characters(char[] chars, int i, int i1) throws SAXException {
if (elementBuilder == null) {
Log.e("MapDemoMYCONTENTHANDLER", "elementBuilder NULL");
elementBuilder = new StringBuilder();
}
elementBuilder.append(chars, i, i1);
}
 
/**
* Parse results
*
* @param mSearch
*            Bundle containing results data
* @return ArrayList<Placemark> containing List of PlaceMark one for each
*         result of the search
* @throws IOException
*/
 
private ArrayList<Placemark> getPlaceMarks(Bundle mSearch) {
ArrayList<Placemark> placeMarks = new ArrayList<Placemark>();
if (mSearch != null)
synchronized (mSearch) {
Bundle placeBundles = mSearch;
Set<String> places = placeBundles.keySet();
Placemark placeMark = null;
Bundle Categories;
String Latitude = "0.0000";
String Longitude = "0.0000";
Double lat;
Double lng;
GeoPoint geoPoint;
String fieldName;
Bundle placeBundle;
Set<String> placeFields;
Set<String> categories;
 
for (Iterator<String> it = places.iterator(); it.hasNext();) {
placeBundle = placeBundles.getBundle(it.next());
placeFields = placeBundle.keySet();
for (Iterator<String> iter = placeFields.iterator(); iter
.hasNext();) {
fieldName = iter.next();
if (fieldName.equals("Categories")) {
Categories = placeBundle.getBundle(fieldName);
categories = Categories.keySet();
for (Iterator<String> itr = categories.iterator(); itr
.hasNext();) {
// TODO utiliser les categories
@SuppressWarnings("unused")
String catName = Categories.getString(itr
.next());
}
} else if (fieldName.equals("Latitude")) {
Latitude = placeBundle.getString(fieldName);
} else if (fieldName.equals("Longitude")) {
Longitude = placeBundle.getString(fieldName);
} else if (fieldName.equals("Title")) {
title = placeBundle.getString(fieldName);
} else if (fieldName.equals("LastReviewIntro")) {
snippet = placeBundle.getString(fieldName);
}
}
// Placemark placemark = search.getPlacemark(i);
// Log.e("GlocationMAP", "MyLocationOverlay...draw
// Search " + i);
Log.e("GlocationMAP", "MyLocationOverlay...snippet "
+ snippet);
lat = Double.valueOf(Latitude) * 1E6;
lng = Double.valueOf(Longitude) * 1E6;
geoPoint = new GeoPoint(lat.intValue(), lng.intValue());
placeMark = new Placemark(geoPoint, title, snippet,
placeBundle);
// placeMark.setMarker(marker);
placeMarks.add(placeMark);
}
}
return placeMarks;
}
}

Ecran de saisie de la requête utilisateur de recherche

Nous allons créer une nouvelle activité SearchActivity pour permettre à l’utilisateur de saisir une recherche.

SearchActivity doit créer un espace de saise du texte et un bouton pour lancer la recherche.

La syntaxe des recherches que l’utilisateur doir entrer est celle de Yahoo Search.

Votre location doit être a l’intérieur des Etats-Unis du à la limitation de Yahoo Search, autrement vous n’aurez aucun résultat.

On limite la longueur a 140 caractères.

SearchActivity.java

package org.example.android.apis;import android.app.Activity;
 
import android.content.Intent;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.view.View;
 
/**
* SearchActivity Activity getting search from user sending result by an intent
*
* @author Andre Charles Legendre
*
*/
 
public class SearchActivity extends Activity {
protected static final String ACTIVITY_RESULT = "org.example.android.apis.EDIT";
 
public SearchActivity() {
}
 
/**
* Called with the activity is first created.
*/
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
 
// Set the layout for this activity.
setContentView(R.layout.search);
 
Button addButton = (Button) findViewById(R.id.searchButton);
addButton.setOnClickListener(new View.OnClickListener() {
 
public void onClick(View v) {
Intent i = new Intent();
// We limit length to 140 to avoid exception in
// MapDemoConnection
String result = ((EditText) findViewById(R.id.searchText)).getText().toString();
if (result.length() > 140)
result = result.substring(0, 139);
i.putExtra(ACTIVITY_RESULT,result);
setResult(RESULT_OK, i);
finish();
}
});
 
}
}

On doit bien entendu déclarer cette Activity dans le fichier AndroidManifest.xml pour pouvoir l’utiliser.

Nous avons par ailleurs ajouté dans MapViewDemo.java une option au menu et un KeyEvent pour KEY_F pour lancer SearchActivity :

Conclusion

Nous voilà au bout de ce tutorials qui nous a permis de voir beaucoup de nouveaux éléments.

Il y en aura encore dans la suite, nous verrons ce que ça donne avec Google Search.

Nous aborderons également le composant WebView et les interactions possible avec Java et  JavaScript. Attention ça va en surprendre plus d’un…

J’attends vos remarques, critiques, propositions d’amelioration.

Télécharger les sources

Pour aller plus loin :

• HTC Magic chez SFR : communiqué de presse et photos officielles
• Encore une mise à jour pour Google Maps
• Google Maps Navigation de retour en Europe
• Google Maps Navigation disponible officiellement pour Android 1.6 Donut
• Tutoriel Android : Introduction aux Intents

Map application pour Android SDK 1.5, deuxième partie - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Pour porter mon application GLocationMap sous le SDK 1.5, j’ai choisi la solution de réécriture pas à pas. Ceci m’a paru nécessaire compte tenu des differences majeures entre le SDK 1.0 et le SDK 1.5 et me permet donc de faire une série de tutoriaux progressifs expliquant en détails l’utilisation des fonctions Maps, GPS et Location Services mais aussi les difficultés rencontrées.

Ce premier tutoriel va présenter les bases d’une application Android élémentaire intégrant Google Maps.

Nous présenterons dans les tutoriaux suivants tout ce qui concerne l’intégration de menus pour interopérer avec la carte, puis les Overlays pour ajouter des informations, puis la recuperation des infos de localisation, la communication avec des serveurs d’application et bien plus encore !

Android Virtual Devices

La version 1.5 du SDK Android introduit une nouveauté avec les Android Virtual Devices, des terminaux Android virtuels configurables dans les moindres détails, qui seront nécessaires au lancement de votre application.

Un Android Virtual Device (AVD) modélise un seul virtual device hébergeant la plateforme Android qui a au minimum son propre Kernel, system image et data partition.

Un emulator process peut lancer un seul AVD à la fois, mais vous pouvez créer plusieurs Android Virtual Devices et les faire tourner en parallèle.

Création d’un AVD : android create avd –name my_avd –target t (t = 1 pour Android 1.1, 2 pour 1.5 etc)

Pour avoir la liste des avds : android list avds

Vous obtenez par ex :

Available Android Virtual Devices:

Name: avd_1.5

Path: /home/rcs/.android/avd/avd_1.5.avd

Target: Android 1.5 (API level 3)

Skin: HVGA

———

Name: my_avd

Path: /home/rcs/.android/avd/my_avd.avd

Target: Android 1.1 (API level 2)

Skin: HVGA

Pour utiliser un AVD :

Si vous lancez votre application depuis Eclipse, l’environnement de développement va identifier automatiquement l’AVD à utiliser en fonction des options de compilation que vous avez choisi.

Pour lancer l’émulateur vous devez specifier le nom de l’AVD que vous souhaitez utiliser : emulator @my_avd

Pour avoir plus de détails sur les AVD : emulator -help-virtual-device

Utiliser Google Maps avec le SDK 1.5

Nous devons en premier éditer le fichier layout de notre application contenu dans le fichier /res/layout/mapview.xml :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/main"
    android:layout_width="fill_parent" 
    android:layout_height="fill_parent">
    <com.google.android.maps.MapView
        android:layout_width="fill_parent" 
        android:layout_height="fill_parent"
        android:enabled="true"
        android:clickable="true"
        android:apiKey="@string/mapskey"
     />
</LinearLayout>

Comme vous le voyez, notre layout ne contient pour l’instant rien d’autre qu’un MapView, élément indispensable pour une application utilisant Google Maps.

Les IDs du LinearLayout et du MapView sont utilisés pour rendre accessibles les Views dans l’Activity.

Pour utiliser les composants Google Maps  une API key est nécessaire, et sera stockée comme une ressource string référencée par la clé @string/mapskey.

Obtenir une clé pour l’API Google Maps :

Android autorise l’installation des applications signées exclusivement. Avant d’installer une application dans l’émulateur, Eclipse va automatiquement signer votre application, utilisant un certificat de debug qui vient avec le SDK Android. Eclipse crée le fichier debug.keystore lors de la compilation (réussie) du projet, stocké dans le répertoire ~/.android. La clé pour l’API Google Maps est basée sur ce certificat de debug. Une explication detaillée expliquant comment signer une application peut facilement se trouver en ligne.

Pour obtenir une Google Maps API key (en utilisant le debug certificate) vous devez suivre les étapes suivantes :

Créer un md5 checksum du debug certificate :
Trouver le debug.keystore

• Vista: C:\Users\\AppData\Local\Android\debug.keystore
• XP: C:\Documents and Settings\\Android\debug.keystore
• Mac, Linux: ~/.android/debug.keystore

Et appeler la commande : keytool -list -alias androiddebugkey -keystore .keystore -storepass android -keypass android

Le md5 checksum est généré et affiché à l’écran :

androiddebugkey, Apr 20, 2009, PrivateKeyEntry,

Certificate fingerprint (MD5): XX:YY:ZZ:AA:BB:CC:FF:CA:A7:99:AD:DD:DF:5C:12:ED

Enregistrer le md5 checksum :

S’enregister sur Google Code pour avoir une Maps API key. Un compte google est requis pour pouvoir le faire.

Saisir le checksum md5 et cliquer sur le bouton “Generate API key”.

Vous obtenez alors une page avec votre Google Maps API key et une petite explication de comment l’utiliser dans un layout.

Editer les resources dans le fichier string.xml :

Copier-coller la Google Maps API key dans le fichier string.xml pour la resource string/mapskey utilisée dans le layout :

<?xml version=“1.0″ encoding=“utf-8″?>

<resources>
    <string name="app_name">MapDemoV1</string>
    <string name="mapskey">XXXXXXXXXX7O2PwQ5YMM6ilp5HCJ4YYYYYYYYYY</string>
</resources>

Ajouter les permissions requises et les librairies au manifest

Notre application nécessite deux permissions :

• Google maps impose l’accès a internet (android.permission.INTERNET)
• La partie Localisation (à venir) impose l’accès au GPS (android.permission.ACCESS_FINE_LOCATION)

De plus, la library Google Maps API (com.google.android.maps) doit être incluse dans le projet.

Notre fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="org.example.android.apis"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="@string/app_name"
            android:icon="@drawable/icon">
                <uses-library android:name="com.google.android.maps" />
         <activity android:name=".MapViewDemo" 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="3" />
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
</manifest>

Le code java

Cette application doit hériter de MapActivity et faire reference au layout défini dans mapview.xml a l’aide de la méthode setContentView.

Le fichier MapViewDemo.java :

package org.example.android.apis;

import android.os.Bundle;
import com.google.android.maps.MapActivity;
 
public class MapViewDemo extends MapActivity {
 
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.mapview);
        }
 
        @Override
        protected boolean isRouteDisplayed() {
                return false;
        }
}

L’application peut être lancée en sélectionnant le projet dans Eclipse, clic droit, Run As, Android Application.

Compilation, exécution, debogage

Il est possible de tester l’application en utilisant l’émulateur.

Pour compiler de facon correcte une application utilisant Google Maps avec le SDK 1.5 vous devez definir le project target comme étant un Google Maps API.

Selectionnez le projet dans Eclipse, clic droit, Properties, Android et sélectionnez sur Google Maps API comme target.

Pour voir défiler le log : adb logcat dans une fenêtre indépendante lorsque l’émulateur est lancé

En cas de problème vous pouvez vouloir effacer les installations précéedentes pour repartir avec un émulateur propre grâce à cette commande : /tools/emulator -wipe-data @avd_1.5

Pour effacer ce que vous souhaitez seulement (attention aux erreurs !) : 

/tools/adb shell (quand l’emulateur fonctionne)

cd /data/app

rm appli.apk

Pour des débugage plus complexe, consultez la doc d’Eclipse. Pour ma part je préfère éviter les erreurs que les déboger !

La suite très prochainement…

Pour aller plus loin :

• Tutoriel Android : GLocation
• Encore une mise à jour pour Google Maps
• Google Maps Navigation de retour en Europe
• Google Maps Navigation disponible officiellement pour Android 1.6 Donut
• Mise à jour de Google Maps pour Android

Map application pour Android SDK 1.5, première partie - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Nous y voilà enfin ! Les “guerriers” qui ont eu le courage de lire les deux premières parties de ce tutorial vont enfin pouvoir arriver à leurs fins. Cette fin c’est la réalisation de votre premier programme sur Android. Comme à l’accoutumée, il m’a semblé judicieux de faire ce que tout bon professeur enseigne à ses élèves lors de l’apprentissage d’une nouvelle technologie ou d’un nouveau langage : un “Hello World”.

Certains d’entre vous ont probablement remarqué qu’avec le plugin ADT (Android Development Tools) d’Eclipse, la création d’un nouveau projet Android revient en fait à la création d’un programme de type “Hello World”. Ce “Hello World” est d’une simplicité enfantine. Cela permet aux débutants de mieux appréhender le développement sur Android. Dans les lignes qui suivent, nous allons créer notre propre “Hello World” en modifiant l’existant. Nous tenterons de l’améliorer d’un point de vue graphique essentiellement.

Note : Les exemples et les copies d’écran ci-dessous ont été effectués sur le SDK 1.5. Ce SDK introduit quelques nouveautés afin de faciliter le développement sur Android. On remarquera par exemple des changements au niveau de l’arborescence du projet par rapport à celle expliquée dans la partie 1 de ce tutorial

Vous noterez dans cette partie que le code Java a volontairement été réduit au maximum. Pourquoi? La réponse est assez simple. Le développement sur Android se fait bien sûr en Java comme il a été précisé dans des parties antérieures. Néanmoins, lorsqu’il s’agit d’interface graphique, le XML est préférable car plus simple et plus lisible. En effet, les ingénieurs de chez Google ont conçu un système d’expansion (inflate) de fichiers XML pour créer des interfaces graphiques. Ces fichiers XML sont ensuite utilisés, en interne par le système, pour générer l’interface graphique. Ce dernier relit les fichiers XML puis créé les objets Java associés de façon automatique.

Note : En réalité, les fichiers XML ne sont pas incorporés dans votre paquet d’installation sous forme XML. Le “parsing” (action de relire un fichier et d’en extraire les informations) est une opération relativement coûteuse. Pour contrer ce problème, les fichiers XML sont en réalité pré-parsés et incorporés sous une forme plus rapide à lire/exécuter dans le paquet d’installation. On conserve ainsi l’avantage de la lisibilité et de la facilité d’utilisation d’un point de vue utilisateur et on optimise d’autre part la relecture de ces fichiers lors de l’expansion de l’interface graphique.

Ce tutorial explique comment créer, à partir de rien, ce premier “Hello World”. La meilleure façon de bien comprendre la totalité de ce tutorial est d’en lire l’intégralité. Si vous n’avez pas réellement envie de vous attarder sur les différents points et préférez attaquer directement le code, les sources et les ressources sont disponibles dans ce fichier.

Maintenant que les quelques précisions ont été données, nous pouvons créer notre premier “Hello World”. Pour ce faire, commençons par créer le projet dans l’environnement Eclipse. Cliquez sur File > New > Other… > Android Project. Une boite de dialogue un peu modifiée en comparaison de celle présentée en partie 1 s’ouvre. Remplissez là comme suit :

Validez la création du projet en cliquant sur Finish. Nous voilà maintenant en présence d’un projet de type “Hello World” affichant simplement un texte à l’écran. Pour lancer l’application sur l’émulateur, cliquez simplement sur Run > Run ou sur l’icône représentant un cercle vert et contenant un triangle blanc. Une boite de dialogue s’ouvre alors et vous demande quel sera le type de l’exécution. Dans notre cas nous souhaitons bien sûr que l’exécution se fasse sous la forme d’”Android Application”.

L’objectif de cette partie est d’améliorer ce “Hello World” en n’utilisant presqu’exclusivement que du XML. Listons tout d’abord les différentes valeurs et ressources que nous utiliserons:

• Les chaines de caractères (strings.xml) : le nom de l’application, la chaine “Hello World”
• Les couleurs (colors.xml) : la couleur de la chaine “Hello World”
• Les dimensions (dimensions.xml) : la taille de la chaine “Hello World”
• Les images (drawable) : l’image de la mascotte Android ou tout autre image qui vous fait plaisir

Commençons par créer les différentes chaines de caractères que nous utiliserons. Ces éléments se trouvent dans le fichier strings.xml. Double cliquez sur ce dernier pour ouvrir la vue de modification. On y retrouve déjà deux chaines de caractères :

La première chaine est “app_name”. C’est le nom qui sera affiché dans le “Home Screen” sous l’icône de l’application. Cette chaine a pour valeur le nom de l’application donné dans la boite de dialogue à la création du projet. Il n’est donc normalement pas nécessaire de la modifier. La chaine “hello” par contre ne satisfait pas à nos critères et nous allons donc changer sa valeur à “Hello World”. Enregistrez le fichier pour valider les changements.

Créons maintenant une nouvelle couleur qui servira pour l’affichage de la chaine de caractère “Hello World”. Il nous faut un fichier colors.xml. De base, ce fichier n’existe pas et il faut donc le créer manuellement. Pour ce faire cliquez simplement sur l’icone Android disposant d’un signe plus vert. Une boite de dialogue, qui a été introduite avec le SDK 1.5, apparait. Nous souhaitons créer un fichier colors.xml qui contiendra des valeurs (values) relatives aux couleurs. ADT s’occupe automatiquement de créer le fichier dans le bon répertoire (c’est à dire res/values).

Le fichier de ressources colors.xml étant maintenant créé, il ne nous reste plus qu’à y ajouter une couleur. La couleur sera le blanc parfait “white” et la valeur associée “#fff”. Cliquez sur Add > Color et remplissez les champs avec les valeurs adéquates. Notez qu’Android gère plusieurs formats de couleurs que sont #RGB, #ARGB, #RRGGBB et #AARRGGBB. Ce sont les notations hexadécimales des couleurs R représentant le rouge, G le vert, B le bleu et A le canal alpha (la transparence).

Pour créer la dimension de la chaine de caractères “Hello World”, il suffit de réitérer l’opération. Comme vous vous en doutez probablement, l’objectif est de créer un fichier dimensions.xml et d’y inclure le couple nom/valeur suivant : “dim_hello”/”20px”. Dans notre cas, nous utilisons les pixels (px) comme mesure mais d’autres dimensions sont disponibles : in, mm, pt, dp et sp.

Ajoutons, pour finir l’image de la mascotte Android dans le dossier des drawables. Il suffit simplement d’effectuer un glisser/déposer dans le dossier drawable à l’aide d’Eclipse. Vous pouvez aussi directement inclure le fichier dans votre workspace puis lancer un rafraichissement de votre projet par un F5 dans Eclipse.

Note : En réalité, Android peut gérer les ressources présentes dans un seul et unique fichier de valeurs. Néanmoins, l’expérience prouve que mélanger les chaines de caractères, les couleurs, les tableaux d’entier, les dimensions, etc. n’aide pas à la compréhension d’un projet. De plus lors de l’internationalisation (i18n), il est inutile de traduire des grandeurs indépendantes de la localisation telles que les couleurs ou les dimensions par exemple. Il est donc préférable de séparer l’ensemble des ressources par type comme il est fait dans ce tutorial.

Toutes les ressources sont maintenant prêtes. Nous pouvons modifier l’interface graphique. Double-cliquez sur main.xml. L’éditeur de “layout” s’affiche. Il vous est possible de créer l’interface en mode graphique ou en tapant simplement le fichier XML à la main. Pour basculer entre les modes, utilisez les onglets en bas de la fenêtre. L’interface graphique étant assez facile d’utilisation, nous allons directement taper le code XML. Notre objectif est d’afficher l’image de la mascotte Android avec un “Hello World” en dessous. Le tout sera également centré quelque soit le type d’écran ou l’orientation utilisé. Le code ci-dessous représente l’interface graphique voulue :

<?xml version="1.0" encoding="utf-8"?>
<linearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:layout_gravity="center_vertical|center_horizontal"
	android:orientation="vertical">
 
	<imageView
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:layout_gravity="center_horizontal"
		android:src="@drawable/tex"
		/>
 
	<textView
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:layout_gravity="center_horizontal"
		android:text="@string/hello"
		android:textColor="@color/white"
		android:textSize="@dimen/dim_hello" />
 
</linearLayout>

De façon globale, l’interface graphique précédente dispose d’un unique élément LinearLayout à la racine englobant deux autres éléments ImageView et TextView. Etudions maintenant plus en détail l’utilité de ses éléments et surtout leurs attributs. Lorsqu’on créé une interface graphique, on souhaite “ranger” les composants graphiques afin que ces derniers s’affiche à l’écran. Parmi les possibilités les plus courantes, on trouve :

• RelativeLayout qui laisse les éléments fils se positionner par rapport au parent (positionnement relatif).
• AbsoluteLayout qui permet aux éléments fils de se positionner de façon exacte par rapport au parent. Un élément fils définit alors une coordonnée exacte.
• FrameLayout est un élément très basique qui oblige l’ensemble de ces enfants à se placer au coin supérieur gauche.
• LinearLayout aligne l’ensemble de ses enfants dans une direction unique : horizontale ou verticale. Les éléments sont ensuite empilés les uns aprés les autres. Ce genre de layout n’affiche donc qu’un seul élément par ligne ou colonne (cela dépend de l’orientation choisie)

Dans notre cas, on souhaite afficher les éléments les uns au dessous des autres. On utilise donc un LinearLayout. Les attributs de l’élément sont ensuite les suivants :

• xmlns:android="http://schemas.android.com/apk/res/android" définit le namespace android. Cette ligne doit obligatoirement être ajoutée à l’élément racine
• android:layout_width="wrap_content" indique à l’élément que sa largeur doit s’adapter au contenu. Les autres valeurs possibles sont “fill_parent” qui indique que l’élément va s’agrandir pour remplir totalement son parent. Il est également possible d’utiliser une dimension pour obtenir une taille fixe
• android:layout_height="wrap_content" indique, à l’instar du précédent que la hauteur doit s’adapter au contenu. Cet attribut est, comme le précédent, obligatoire pour l’ensemble des éléments graphiques car il permet au système de connaitre avec exactitude la place prise par l’élément à l’écran
• android:layout_gravity="center_vertical|center_horizontal" oblige l’élément à se centrer de façon verticale et horizontale dans son parent
• android:orientation="vertical"

permet d’orienter le layout de façon verticale. Les éléments seront empilés les un au dessous des autres

On insère ensuite dans le layout l’image. Cette dernière est incluse grâce à la vue ImageView à laquelle on assigne, grâce à l’attribut android:src, l’image de la mascotte. Cette image a pour nom original “tex.png” et se trouve dans le dossier drawable. Pour l’inclure on utilise donc la syntaxe @drawable/ suivi de son nom sans l’extension. L’inclusion d’une zone de texte suit la même logique. On utilise une TextView à laquelle on associe les différentes valeurs préparées en début de partie. La valeur android:text se trouve dans le fichier strings.xml, on y accède donc par @string/hello.De la même façon, on accède à la couleur par @color/white et à la dimension par @dimen/dim_hello. Notre interface graphique est maintenant terminée. Il nous reste à l’utiliser dans notre code Java. Il suffit de se rendre dans HelloWorld.java. Ce fichier contient le code suivant :

package com.cyrilmottier.android.helloworld;
 
import android.app.Activity;
 
import android.os.Bundle;
 
public class HelloWorld extends Activity {
 
    /** Called when the activity is first created. */
 
    @Override
 
    public void onCreate(Bundle savedInstanceState) {
 
        super.onCreate(savedInstanceState);
 
        setContentView(R.layout.main);
 
    }
 
}

On ne peut pas faire plus simple ! HelloWorld hérite bien d’Activity et c’est ce que nous souhaitons puisque, comme expliqué dans la partie 2, une activité permet d’afficher une interface graphique à l’utilisateur. La mise en place de notre interface graphique s’effectue simplement en redéfinissant la méthode onCreate. On applique simplement la vue créée à l’aide de setContentView(int). L’entier passé à cette méthode est la référence de notre layout. C’est ici qu’on utilise le fichier automatiquement géré R.java. Si vous n’avez pas changé le nom du fichier de votre interface graphique, il devrait être référencé par R.layout.main.

Nous y voilà ! Notre “Hello World” est prêt ! Cela peut sembler incroyable puisque nous n’avons presque pas écrit de code Java. C’est là que se trouve une des puissances d’Android : l’instanciation d’objets par XML. Nous avons créé ici une interface graphique mais d’autres objets non graphiques sont également instanciables via XML. Vous pouvez maintenant lancer votre premier programme sur l’émulateur et contempler le résultat :

Pour aller plus loin :

• Android SDK 2.1 disponible !
• Nouvelle mise à jour pour le SDK Android
• L’Android SDK 2.0 est dispo !
• Tutoriel Android : Introduction aux Intents
• Donut arrive ! SDK Android 1.6 disponible au téléchargement

Tutoriel Android : "Hello World" version 1.5 - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Google vient de publier un tutoriel, expliquant comment créer un widget simple pour Android, affichant le mot du jour de Wiktionary.

C’est simple et bien expliqué, alors si le développement de widgets Android vous attire, foncez !

D’ailleurs, c’est un sujet très intéressant, et je reviendrais dessus dans un tutoriel maison très prochainement.

Pour aller plus loin :

• Tutoriel : Changer la skin de l'émulateur Android
• Tutoriel : Installation du SDK Android
• Android SDK 2.1 disponible !
• Nouvelle mise à jour pour le SDK Android
• L’Android SDK 2.0 est dispo !

Tutoriel : Développer un widget Android - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Lorsque l’on aborde une nouvelle technologie, on souhaite d’emblée réaliser un premier projet. Etant passé maintes fois par cette étape, je comprend votre engouement à réaliser votre première application Android. Malheureusement, avant d’effectuer un premier et traditionnel “Hello World”, il me semblait plus utile d’introduire les composants principaux d’Android. Je tiens tout de même à rassurer ceux qui souhaiterait décrocher maintenant : nous allons attaquer le vif du sujet avec le développement d’une première application dans la prochaine partie de cette série de tutoriaux !

Le développement sur Android s’appuie sur des classes importantes du framework. Ces classes sont, en quelque sorte, les “briques” élémentaires sur lesquelles vos futures applications reposeront. Elles sont tellement indispensables qu’il est tout simplement impossible de contruire votre application sans passer par au moins l’une d’elles. Cette partie tente de décrire de façon globale et succincte ces différentes “briques”.

Intent

Les Intents sont des objets permettant de faire passer des messages contenant de l’information entre composants principaux. La notion d’Intent peut être vue comme une demande de démarrage d’un autre composant, d’une action à effectuer. La raison d’être des Intents provient du modèle de sécurité d’Android. Chaque application est en effet sandboxée. Cela veut dire qu’une application A ne peut accéder aux données d’une application B. Grâce aux Intents, les applications ont la possibilité de fournir leurs services ou données si elles le souhaite.

View

Les Views sont les composants de base de l’interface graphique. Elles permettent de construire l’interface utilisateur. Les widgets (nom donné à des composants graphiques “avancés” : une barre de progression, par exemple, est un widget), composants graphiques ou autres layout (composant permettant de placer les différents composants graphiques à l’écran) héritent en fait de cette classe élémentaire. Le rendu/dessin d’une View s’effectue par l’intermédiaire d’un Canvas (qu’on peut assimiler à une feuille transparente sur laquelle on dessine avec un crayon (Paint). Pour finir, la vue est le principal composant qui s’occupe de gérer les actions utilisateurs (appui sur l’écran, sur le clavier, etc.).

Lorsqu’on créé une application à l’aide du framework Android, le développeur doit hériter d’au moins une des 4 classes brièvement décrites ci-dessous. Ces notions de composants applicatifs vous sembleront, j’en suis sûr, totalement déroutantes au premier abord. Gardez à l’esprit que vos développements et les différentes parties de ce tutorial, vous permettront de clarifier vos idées.

Activity

le concept d’Activity repose sur la notion d’interaction utilisateur. Une Activity représente la fenêtre ou tout simplement l’écran qui sera affiché à l’utilisateur. Elle permet également de gérer des fonctionnalités telles que l’appui sur la touche [MENU] ou l’affichage de messages d’alerte (Toast). Faites bien attention à ne pas confondre la notion d’Activity et de View. Il est évident que faire la différence entre ces deux notions est difficile à ce stade de compréhension du framework. Rappelez vous que vos premières réalisations vous permettront de dissocier les deux : Soyez patient!

Service

La notion de service est un avantage certain sur l’iPhone. En effet, un Service est en fait un programme tournant en tâche de fond et n’ayant pas d’interface graphique (ce qui n’est pas réalisable, à l’heure où j’écris ces lignes, sur iPhone OS). L’exemple commun illustrant au mieux cette notion est celui du lecteur mp3. Un lecteur mp3 ne nécessite pas, pour la plupart du temps, d’interface graphique et doit tourner en tâche de fond laissant la possibilité aux autres applications de travailler/s’exécuter librement.

ContentProvider

Les ContentProvider sont, comme l’exprime leurs noms, des gestionnaires de données. Ils permettent de partager l’information entre applications. Imaginons une application qui permette de conserver les cartes de visite virtuelles d’un ensemble de personnes. Ces cartes de visite contiennent généralement le nom, le prénom et un moyen de contact de la personne. Un tel programme peut être créé sous forme de ContentProvider ce qui lui permettra de fournir à d’autres applications présentes sur le système les informations sur une personne. Une application tierce d’envoi de courriel peut par exemple interroger ce ContentProvider afin d’obtenir l’adresse courriel d’un contact.

BroadcastReceiver

Pour finir, un BroadcastReceiver est une application qui est à “l’écoute” des autres applications. Ce type d’application tente de répondre auxIntents qui lui sont adressés. Il ne fait donc rien d’autres que d’être à l’écoute des Intents envoyés par d’autres composants applicatifs.

Conclusion

Vous connaissez maintenant les différents éléments utilisés dans une application Android. Si vous voulez des détails sur certains points ou si vous avez des questions, n’hésites pas à les poser dans les commentaires.

Pour aller plus loin :

• Tutoriel Android : Introduction aux Intents
• Des exemples d'applications Android par Google
• Tutoriel : Arborescence d'un projet Android

Tutoriel : Les composants principaux d'Android - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Les différents mode de connexion réseau

Il est important de bien connaître les différents modes de connexion internet de votre téléphone et leur consommation d’énergie, pour savoir quel mode utiliser dans quel situation et ainsi optimiser l’autonomie.

Le HTC Dream peut se connecter à internet grâce à 3 modes de connexion, qui ont chacun leurs avantages et leurs inconvénients :

• Wi-Fi : Le mode de connexion de plus rapide mais aussi le plus gourmand ! A utiliser de préférence quand une prise de courant est à portée, ce qui est généralement le cas quand on est à proximité d’un réseau Wi-Fi.
• 3G : Le mode de connexion principal de votre G1, à condition d’être dans une zone couverte. La 3G consomme bien évidemment plus d’énergie que la 2G, mais c’est le meilleur rapport confort d’utilisation/consommation.
• 2G ou EDGE : Le EDGE, c’est lent, mais c’est aussi le mode de connexion qui consomme le moins et qui vous permettra d’économiser votre batterie au maximum. A n’utiliser que si votre téléphone est presque à plat ou si vous êtes dans un zone où la 3G est absente.

Bien gérer votre mode de connexion vous permettra de prolonger la durée d’utilisation de votre G1. Laborieux? Heureusement, il existe des applications pour vous simplifier la tâche.

Power Manager : Une application intelligente pour gérer la batterie votre G1

Il existe un certain nombre d’applications vous permettant de gérer les différents éléments de votre HTC Dream, mais la plus populaire est sans conteste Power Manager, disponible sur l’Android Market.

Cette application vous permettra d’activer ou désactiver les différents éléments de votre G1 en fonction du taux de charge de la batterie.

Par exemple, vous pouvez faire en sorte que le GPS ou le BlueTooth se désactivent automatiquement quand la batterie passe sous les 30% de charge.

Il est également possible de régler la luminosité de l’écran (à mettre au plus bas pour économiser la batterie), la durée pendant laquelle l’écran reste allumé, désactiver la synchronisation des données, etc.

Vous pouvez également régler tous ces paramètres à la main en un seul clic !

Power Manager est une application très complète, qui bien paramétrée, vous permettra d’allonger efficacement la durée de vie de votre batterie.

Dans un registre similaire, il y a aussi Locale (application gagnante de l’Android Developer Challenge), qui vous permettra de définir des réglages selon votre localisation GPS.

Vous avez réglé votre HTC Dream dans les moindres détails et pourtant votre batterie se décharge encore trop vite à votre goût? Une seule solution : les accessoires !

Les accessoires

Le G1 est sorti il y a seulement quelques mois mais il existe déjà toute une série d’accessoires pour accompagner votre appareil. Pour le sujet qui nous intéresse à savoir l’autonomie, il existe notamment des batteries de plus grande capacité, des chargeurs externes bien plus rapides que le chargeur USB ou encore des chargeurs de voiture. Je vous proposerais d’ailleurs une sélection d’accessoires dans un prochain article.

Vous avez essayé certains accessoires pour améliorer l’autonomie de votre HTC Dream? Quels sont les résultats?

Conclusion

En respectant ces quelques conseils et en investissant éventuellement dans une batterie de plus grand capacité, vous pourrez améliorer grandement l’autonomie de votre HTC Dream (et ils sont bien évidemment valables pour les futurs smartphones Android) et vous aurez besoin de le recharger beaucoup moins souvent.

Et vous, combien de temps dure la batterie de votre G1 ou HTC Dream? Avec quelle utilisation?

Si vous avez d’autres astuces pour prolonger la durée de vie de votre batterie, n’hésitez pas à les partager dans les commentaires. J’éditerais le post avec vos suggestions.

A noter que Cupcake, la prochaine version d’Android, améliorera la gestion de l’énergie.

PS : Cet article, bien que loin d’être une traduction littérale, est clairement inspiré de ce post de l’excellent Android and Me. Ca faisait longtemps que l’idée d’un post sur le sujet me trottait dans la tête mais l’article en question est complet et je ne voyais pas l’intérêt de réinventer complètement la roue.

Pour aller plus loin :

• Statistiques d'utilisation du G1 par T-Mobile
• Google récompense les meilleurs développeurs Android
• Android Market : Une success story à 13 000 dollars par mois
• Android Market : Nouvelle mise en avant des applications
• Quoi de neuf sur l’Android Market? La Conjugaison, Freebox Mobile, NewsRoom…

Améliorer l'autonomie de votre smartphone Android - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

La programmation sur Android commence tout d’abord par l’installation du SDK Android fourni par Google sur le site des officiels des développeurs. La rédaction d’une suite de tutoriaux sur le développement sur Android devrait tout naturellement contenir une partie introductive expliquant cette étape. Néanmoins, je n’ai pas souhaité inclure cette partie car elle est facilement réalisable et la documentation déjà existante est déja suffisante :

• http://developer.android.com/sdk/ : Site officiel des développeurs Android (en anglais)
• http://www.pointgphone.com/tutoriel-installation-sdk-android-51 : Un tutoriel qui date un peu sur PointGPhone mais qui reste d’actualité vu les changements quasi inexistants sur la procédure d’installation.
• http://android.cyrilmottier.com/?p=3 : Article récent sur mon blog personnel.

Comme le mentionne le titre de cette partie, l’objectif de ce tutorial est de se familiariser avec l’arborescence type d’un projet Android. Nous étudierons donc les différents packages et dossiers qui sont automatiquement créé par le plugin ADT (Android Development Tool). Pour ce faire, créons tout d’abord un premier projet avec l’EDI Eclipse. Lorsque vous faites File>New>Other>Android Project, une boite de dialogue comme représentée ci-dessous s’ouvre :

Cette boite de dialogue demande en réalité d’entrer plusieurs informations sur le projet :

• Project Name : Ce nom de projet est totalement indépendant de votre application Android. Ce n’est en fait que le nom donné à votre projet dans Eclipse (nom donné au dossier dans votre workspace).
• Package Name : Nom du package principal de l’application. Le nom du package suit, en général, la règle suivante : extension_de_votre_domaine.nom_du_domaine.android.nom_du_projet (par exemple : com.cyrilmottier.android.tutorial). Le package définira en fait le nom interne de votre application sur le terminal Android.
• Activity Name : C’est le nom de l’activité qui débutera au lancement de votre application. Dans une future partie, j’expliquerai le concept d’activité mais pour l’instant nous pouvons simplement considérer qu’une activité est la couche de présentation de votre application (concept d’écran). Ce nom d’activité sera automatiquement ajouté à votre AndroidManifest.xml (fichier qui décrit votre application au système Android et qui sera expliqué plus en détail dans la suite de ce tutorial)
• Application Name : Pour finir vous devez entrer le nom de votre application. Cette chaine de caractère sera également inscrite dans AndroidManifest.xml et sera en fait utilisée par le système lors de l’affichage des applications dans l’écran d’accueil. C’est en réalité le nom de l’application affichée sous l’icône de l’application (nom utilisateur).

Note : Il n’y a aucune règle régissant et reliant les différents noms donnés ci-dessus. Vous pouvez en effet avec un package com.cyrilmottier.android.aviation, un nom d’Activity MonChien et un nom d’application “Cuisinez !”. On remarquera néanmoins, que dans l’exemple précédent, malgré un choix fantaisique poussé à l’extrême des noms, la compréhension du projet n’est absolument pas facilitée.

Après avoir validé la boite de dialogue précédente en cliquant sur “Finish”, nous nous retrouvons maintenant en présence d’un projet type Android. Ce projet suit une arborescence bien précise qui ressemble à celle représentée ci-dessous :

Comme à l’accoutumée, Android ne déroge pas à la régle et insère donc les différents packages dans le dossier src. C’est dans ce dossier que l’ensemble des fichiers de code (.java) doivent se trouver. Il est bien sûr possible de créer de nouveaux packages comme les développeurs Java ont l’habitude de le faire. Analysons maintenant le contenu du package com.cyrilmottier.android.tutorial. On y retrouve tout d’abord un fichier PartOne.java qui n’est autre que l’activité (Activity) principale de l’application. Un simple coup d’oeil au code contenu dans le fichier montre que PartOne hérite bien d’Activity :

package com.cyrilmottier.android.tutorial;
 
import android.app.Activity;
import android.os.Bundle;
 
public class PartOne extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

En dessous du dossier src, on retrouve un fichier android.jar. C’est tout simplement ce jar qui contient l’ensemble du framework Android. Sans ce dernier, notre projet Android serait tout simplement une coquille vide.

On retrouve ensuite dans le package par défaut le fameux R.java. Ce fichier est automatiquement géré par ADT et n’est donc pas modifiable par l’utilisateur. Ce fichier contient en fait l’ensemble des références vers les ressources de votre projet. Imaginons par exemple que nous souhaitions utiliser une image (Drawable dans le langage Android), on y accèdera par R.drawable.nom_de_l_image.

Au même niveau que le dossier src, on retrouve un dossier nommé assets et qui contient simplement des données qui seront chargées sur le mobile lors de la compilation de votre projet. Les données inclues dans ce dossier ne sont normalement pas en accord avec l’arborescence classique d’un projet Android : cela peut, par exemple, être des fichiers texte décrivant la license de votre application, des fichiers audio ou vidéo, etc.

Un projet Android contient enfin un dossier res qui regroupe l’ensemble des ressources relatives au projet. C’est ce dossier qui est “lu” par ADT pour créer le fameux R.java. Ce dossier contient lui même des sous dossiers regroupant les ressources selon leur type. A la création d’un projet Android, les sous-dossiers créés sont :

• drawable : regroupera l’ensemble de vos images (png, jpg, gif), Drawables, etc. On pourrait traduire ce dossier par l’expression (pas vraiment française) “dessinable”.
• layout : le framework Android a l’avantage d’offrir une technique de création d’interfaces graphiques à l’aide de fichiers XML (on étudiera dans de futures parties que le concept a même été porté à l’extrême et qu’un grand nombre de classes peuvent être instanciées par XML) . C’est dans ce dossier que vous incluerez l’ensemble des fichiers décrivant vos interfaces.
• values : ce dossier contient également un ensemble de fichiers décrivant les valeurs utilisées par votre application. On peut, par exemple, y mettre des chaines de caractères (strings.xml), des tableaux (arrays.xml), des couleurs, des dimensions, etc…

Pour finir, tout projet Android contient un fichier nommé AndroidManifest.xml qui définit le comportement de votre application au système Android. Ce fichier définit par exemple, le nom, l’icone (par défaut drawable/icon.png), le thème, la version minimale du système nécessaire à l’exécution de l’application, les activités, les services, etc. de votre application.

Pour aller plus loin :

• Tutoriel Android : Introduction aux Intents
• Tutoriel : Les composants principaux d'Android

Tutoriel : Arborescence d'un projet Android - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.

Passer en mode root ou “rooter” votre HTC Dream est une manipulation qui vous permettra d’avoir un contrôle total sur votre appareil, et vous permettra par exemple de pouvoir installer des applications sur la carte SD de votre téléphone ou… permettre l’utilisation de l’apostrophe manquante du clavier du HTC Dream !

Réaliser cette manipulation n’est pas bien compliqué, il vous faudra installer le SDK Android, télécharger quelques fichiers et éxécuter un certain nombre de procédures dans un ordre précis, le tout détaillé dans un tutoriel en français.

Il vous sera ensuite possible d’assigner une touche à la fameuse apostrophe manquante du clavier du HTC Dream, manipulation également détaillée dans le tutoriel.

Vous êtes passés en mode root? Partagez votre expérience !

Pour aller plus loin :

• Le Motorola Milestone enfin rooté !
• Un Eclair pour le HTC G1?
• Android 2.0 Eclair sur un HTC Dream
• Rooter votre smartphone Android en un clic?
• HTC Dream Orange : Mise à jour Android 1.5 Cupcake enfin disponible !

HTC Dream : Passer en mode root - Point GPhone
Devenez développeur Android grâce à notre formation vidéo.