Android News

De nouveaux Android arrivent

dgirard — Sat, 10 Oct 2009 11:54:00 +0200

Je viens de recevoir ce message de la part de l’équipe Android Market :

Hello,
We're writing to inform you about a couple changes to Android Market that require your attention.
First, we have added the ability to target applications by carrier in all countries. For example, if you are showing your app in the United States, you can now choose among Sprint, T-Mobile, and Verizon Wireless. If your apps are intended for users of specific carriers, please go to the Android Market developer website at http://market.android.com/publish (in the Publishing Options section under Locations) and target your applications to those carriers accordingly.
Second, Android Market will soon be available on devices with different screen sizes. Until now, Android devices have only had "normal"-sized screens, e.g., HVGA (320x480). The latest platform release, Android 1.6, expands support for upcoming devices that cover three different screen sizes: small, normal, and large. Please note that Android Market will allow apps built with the Android 1.5 SDK (or lower) to show only on normal- and large-screened devices. Android Market will allow apps built with the Android 1.6 SDK to show on all three screen sizes. Therefore, you will need to upgrade your app to Android 1.6 if you want it to also show on small screen devices that will launch in the coming weeks. For complete details on Android's support for different screen sizes and the implications for your apps, we strongly recommend that you read the Android Developers Blogpost at http://android-developers.blogspot.com/2009/10/support-for-additional-screen.html.
Thanks, and we look forward to continue working with you on Android
Market.
Sincerely,

The Android Market Team

Sortie du SDK Android 1.6

Patrice — Wed, 16 Sep 2009 22:26:00 +0200

Le nouveau SDK 16 viens de sortir, et apporte son lot de nouveautés. Il intègre les nouvelles fonctions d'android 1.6 :

Gestion de plusieurs tailles d'écran
La fonction de recherche globale
La nouvelle version du market place
La fonction text2speach

Une petite vidéo de présentation :

Android 1.6 Official Video

Démonstration de Donut 2.0

Patrice — Mon, 27 Jul 2009 12:30:00 +0200

Sur le blog Autoroot, Alexandre a fait un test complet de la prochaine version de Donut, la prochaine version d'Android (qui n'est probablement pas la version 2.0). Le tout agrémenté d'images et surtout d'une vidéo.

Retrouvez le test ici :

http://www.autoroot.com/2009/07/26/jai-teste-le-systeme-android-donut-beta-sur-un-htc-dream/

Merci à Alexandre qui nous a donné cette info.

HTC HERO - Démonstration

Christophe — Wed, 24 Jun 2009 16:21:00 +0200

Pour ceux qui suivent l'actualité sur Android, plusieurs vidéos et "news" circulaient sur la toile ces derniers mois sur le prochain téléphone d'HTC, surnommé HERO. Toutes nous promettaient une interface utilisateur complètement revisitée par HTC. Aujourd'hui avec l'annonce officielle de sa commercialisation, voici une petite vidéo qui l'accompagne.

Vidéo du HTC HERO

voir la video sur youtube

Tests unitaires sous Eclipse avec le plugin Android

Florent — Mon, 15 Jun 2009 16:36:00 +0200

Lorsqu’on travaille avec le plugin Android pour Eclipse, le lancement d’une configuration de type JUnit échoue avec un message qui ne vous aidera pas vraiment :

Cela est dû à l’inclusion du jar android dans le classpath ; ce jar contenant sa propre version de JUnit destinée à être utilisée dans un système Android, cela explique alors cette erreur (quoique …).

Dans la fenêtre «Run configurations», onglet «Classpath», vous trouverez une ligne «Android 1.5» que vous pouvez supprimer. Dorénavant les tests unitaires seront lancés avec une version standard de JUnit.

Pour éviter cette manipulation à chaque fois qu’une configuration de test est créée, vous avez aussi la possibilité d’utiliser TestNG. Ainsi vous n’aurez plus de conflit avec le jar d’Android (bien entendu il s’agit d’utiliser les classes propres à TestNG et pas le support de JUnit). Le support de TestNG n’est pas intégré par défaut dans Eclipse, il existe pour cela un plugin.

Binding JSON/Javabeans avec Jackson

Florent — Fri, 12 Jun 2009 15:33:00 +0200

Nous avions déjà vu comment sérialiser des objets en XML en utilisant des annotations, il est également possible de sérialiser/désérialiser des Javabeans en JSON en quelques lignes avec Jackson. Nous pouvons isoler ces lignes de code dans une classe JsonSerializer :

public class JsonSerializer implements Serializer
{
    private ObjectMapper om = new ObjectMapper();

    public void serialize(OutputStream os, Object o) throws IOException
    {
        serialize(new OutputStreamWriter(os), o);
    }

    public void serialize(Writer writer, Object o) throws IOException
    {
        try
        {
            om.writeValue(writer, o);
        } catch (JsonMappingException e)
        {
            System.out.println(e.getMessage());
        }
    }

    public <T> T deserialize(Reader reader, Class<T> clazz) throws IOException
    {
        return om.readValue(reader, clazz);
    }
}

Maintenant, dans un Service ou un Adapter Android, nous pouvons lire/écrire nos Javabeans dans des flux JSON :

JsonSerializer js = new JsonSerializer();

// exemple de sérialisation

js.serialize(flux, new Person("Florent", "Cappelle")
            {{
                    setTels(Arrays.<Tel>asList(new Tel("012345678", Tel.HOME_LANDLINE)));
                    setTels(Arrays.<Tel>asList(new Tel("062345678", Tel.MOBILE_LINE)));
                }}

);

// désérialisation

Person result = js.deserialize(reader, Person.class);

Le mécanisme de sérialisation utilise les noms des getters et les valeurs qu’ils retournent pour générer le flux JSON. Les collections et tableaux sont convertis en leurs équivalents en JSON, ce qui donne par exemple :

{“adresses”:[],”emails”:[], “firstname”:”Florent”, name:”Cappelle”, “tels”:[“number”:”0612345678”, “type”:1]}

Il est possible d’ignorer certains getters en les annotant avec @JsonIgnore et il existe d’autres annotations pour adapter vos Javabeans avec un format JSON prédéfini.

Jackson est donc un choix pertinent pour la stack de développement Google étant donné qu’il fonctionne aussi sur Google App Engine (sans avoir à le modifier contrairement à XStream).

À noter aussi que Jackson fournit des providers pour JAX-RS ainsi qu’une API bas niveau (et donc plus rapide).

Android HiveGotContacts : Lancement de l'application

Adrien — Wed, 03 Jun 2009 12:50:00 +0200

Nous lançons aujourd'hui simultanément plusieurs "produits" liés entre eux pour faciliter la gestion de votre identité numérique, un des produits concernés se trouve être une application Android : HiveGotContacts.

Elle réutilise le concept de Hive déjà rencontré précédemment sur ce blog pour mettre en place un nouveau carnet de contacts, et est enrichie à travers ses possibilités d'interaction avec de nombreux formats existants (les vCards, les domaines en .tel), ainsi qu'avec un nouveau format, Ergosoom, qui se lie avec l'application de gestion du même nom.

Un visuel de l'application.

On retrouve donc plusieurs applications :

- Ergosoom, une application GWT/AppEngine qui permet de se créer un profil virtuel. ( http://www.ergosoom.com )

- DroidAnalytics, une application JSP/AppEngine qui nous aide à tracer les exceptions d'Android ( http://www.droidanalytics.com )

- HiveGotContacts, une application pour Android qui permet de gérer ses contacts dans une interface innovante, et qui apporte de nouvelles fonctionalités par rapport au gestionnaire classique. ( http://market.android.com/search?q=hivegotcontacts )

Tout n'est sans doute pas encore parfait, n'hésitez pas à nous envoyer vos retours si vous décidez d'utiliser ces applications, afin que nous puissions les faire évoluer dans le bon sens.

L'équipe, de gauche à droite, Christophe, Adrien, Didier, Patrice, Florent et Gregory.

Note : L'application est open-source et son code est consultable sur Google Code ici : http://code.google.com/p/hivegotcontacts/

Android 2.0 DONUT

Christophe — Thu, 28 May 2009 11:40:00 +0200

Voici une première démonstration des nouvelles fonctionnalités de “DONUT” réalisée

par Romain GUY lors du GOOGLE I/O 2009

Pour les impatients, allez directement à la 4ème minutes…

Vidéo du GOOGLE I/O sur Android

video sur youtube

Utilisation de XStream sous Android

Florent — Mon, 25 May 2009 17:16:00 +0200

XStream est une bibliothèque Java qui permet de sérialiser et de désérialiser des objets en s’appuyant sur la réflexion et des Converters pour la plupart des types de base (Float, Integer, Collections, ...). La dernière version (1.3.1) fonctionne plutôt bien sous Android.

Il est possible de paramètrer la sérialisation afin d’adapter une classe Java à un format XML particulier et aussi d’éviter d’avoir le nom complet (avec le package) de la classe dans le XML de sortie. Pour cela, Xstream dispose d’annotations et des méthodes correspondantes dans XStream pour les version de Java antérieures à JavaSE 5.

Exemple avec les annotations :

@XStreamAlias("person")

public class Person implements Serializable {

    private String name;

    private String firstname;

    @XStreamImplicit(itemFieldName="email")

    private List<Email> emails;

    @XStreamImplicit(itemFieldName="tel")

    private List<Tel> tels;

    public Person() {

    }

    // utiliser xstream.processAnnotations(Person.class);

}

Et l’équivalent avec les méthodes de XStream :

xstream.alias("person", Person.class);

xstream.addImplicitCollection(Person.class, "emails", "email",
Email.class);

xstream.addImplicitCollection(Person.class, "tels", "tel", Tel.class);

Et le résultat de la sérialisation d’un objet Person :

Au niveau des limitations, la plateforme Android ne supporte pas les parseurs StAX et par conséquent le Driver JettisonMappedXmlDriver qui permet de sérialiser/désérialiser en JSON. De plus, XStream s’appuie sur la variable «java.specification.version» afin de déterminer la version de Java : Android fixe cette variable à 0.9, ce qui désactive la gestion des annotations Xstream.

Toutefois, il est possible d’étendre la classe XStream et de redéfinir la méthode qui crée les classes de mapping afin de pouvoir utiliser les annotations Xstream. Il s’agit de la classe AndroidXStream dans l’archive zip associée à ce billet.

L’analyse des annotations est beaucoup plus lente que les méthodes de la classe XStream mais ces dernières rendent le code plus difficile à maintenir à mon goût.

Il est également possible d’utiliser le Driver JsonHierarchicalStreamDriver afin de sérialiser un objet en JSON, par contre la désérialisation n’est pas supportée. Il faudra alors utiliser les classes du package org.json (déjà présent dans l’API Android).

XStream se révèle particulièrement utile avec les Web Services qui utilisent des formats assez complexes. Pour persister des données en local les classes ObjectOutputStream et ObjectInputStream seront plus efficaces.

Vous trouverez un projet d’exemple dans cette archive : XstreamDemo.zip

Android Captcha : Réutiliser un composant Google

Adrien — Fri, 15 May 2009 12:09:00 +0200

L'interface de base d'Android possède de nombreux gadgets qui s'avèrent très intéressants. Cependant, tous ne sont pas visibles publiquement dans la librairie, mais Android étant un projet open source, et les sources étant accessibles, il est donc tout à fait possible d'aller les récupérer pour les adapter.

C'est le cas du « sliding captcha » utilisé pour verrouiller l'écran de votre téléphone. Ce gadget repose sur les classes LockPatternView et LinearLayoutWithDefaultTouchRecipient disponibles sur le repository google ici : Lien vers le repository (ou en fichier joint avec le projet captcha dans leur version déjà adaptée).

Le code-source de google est comme toujours assez clair. Ici, il nous est proposé une interface OnPatternListener que nous pouvons implémenter pour fabriquer notre propre PatternListener et gérer nous même nos patterns.

De base, le composant est programmé de façon à essayer d'aller interagir avec le captcha de sécurité stocké dans votre téléphone. Il faut donc se débarrasser de cette partie, et la remplacer par notre propre Listener.

C'est ce qui est fait avec MyPatternListener et quelques modifications dans le LockPatternView (voir code source joint avec cet article). Le code n'est pas très compliqué et très simple à mettre en œuvre.

On voit également que l'aspect graphique dépend de bitmaps qui sont chargés, et qu'on peut donc les modifier pour s'approprier le captcha. C'est ce qui a été fait ici, avec une version hexagonale des zones d'appui, pour faire un composant qui puisse s'accorder dans une application avec les HiveLayouts déjà vus précédemment par exemple.

On pourrait envisager des extensions pour offrir plus de possibilités différentes de patterns, ou même qui sait, un jour, le support du multitouch, mais ce sera l'objet d'un éventuel billet ultérieur.

Les developpeurs francais peuvent vendre leurs applications Android

dgirard — Wed, 13 May 2009 10:39:00 +0200

Eric Chu :

We have also added seller support for developers from Germany, France,
Spain, the Netherlands, and Austria. Developers from these countries can
now go to the publisher website to publish their priced applications.
Google Checkout serves as the payment and billing mechanism for Android
Market in all countries. Developers who do not already have a Google
Checkout merchant account can easily sign up for one via the publisher
website. Developers can find more information about priced applications
in Android Market at http://market.android.com/support/.

Recu par email.

Android Cupcake 1.5 : Réaliser son widget

Adrien — Thu, 07 May 2009 11:15:00 +0200

Bonjour, depuis la sortie du dernier framework, une nouvelle possibilité réclamée depuis longtemps est apparue : la possibilité de faire vos propres widgets et de les ajouter sur votre home. Nous allons voir dans les grandes lignes ce qu'il faut faire, les limitations, et vous retrouverez en pièce jointe un widget HelloWorld déjà fait.

Les éléments importants :

Dans AndroidManifest.xml :

<receiver android:name=".MonWidget" android:label="@string/app_name">
           <intent-filter>
               <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
           </intent-filter>
           <meta-data android:name="android.appwidget.provider"
               android:resource="@xml/widget" />
       </receiver>

Il faut récupérer l'action APPWIDGET_UPDATE, et signaler la position d'un fichier xml qui décrit le widget, ici le fichier xml/widget.xml :

<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
   android:minWidth="146dip" android:minHeight="72dip"
   android:updatePeriodMillis="2000" android:initialLayout="@layout/widget_layout" />

Il spécifie une taille minimale pour le widget. Pour obtenir la taille, mutipliez le nombre de cases voulues par 74 dip, puis enlevez 2 dip. Il faut également spécifier la période de mise à jour du widget, vous devriez garder cette valeur la plus haute possible pour réduire la consommation de votre widget, n'utilisez de faibles valeurs que pour le dev. Il faut également spécifier un layout initial pour notre widget, il s'agit d'un layout standard comme tout layout xml d'android, mais il subit les limitations que nous verrons plus bas.

Et enfin la classe MonWidget :

public class MonWidget extends AppWidgetProvider {
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager,
            int[] appWidgetIds) {

        RemoteViews updateViews = new RemoteViews(context.getPackageName(),
                R.layout.widget_layout);

        updateViews.setTextColor(R.id.text, 0xFF000000);
        updateViews.setTextViewText(R.id.text, "Bonjour, Android");

        ComponentName thisWidget = new ComponentName(context, MonWidget.class);
        appWidgetManager.updateAppWidget(thisWidget, updateViews);
    }
}

Cette classe hérite AppWidgetProvider, la nouvelle classe du 1.5 qui est dédiée à la création de widget. Pour faire des actions à chaque update, il faut surcharger la méthode onUpdate et récupérer une RemoteViews de la manière ci-dessus.
Cependant, les widgets souffrent de limitations : la manipulation des vues doit se faire à travers le XML, et vous êtes obligés d'utiliser uniquement des vues de la liste suivante, sans possibilité d'y ajouter les vôtres :

AbsoluteLayout AnalogClock Button Chronometer FrameLayout ImageButton ImageView LinearLayout ProgressBar RelativeLayout TextView
De plus, la manipulation de RemoteViews offre assez peu de possibilités, il ne sera donc même pas possible d'utiliser toutes les fonctionnalités des vues autorisées (particulièrement au niveau de la détection de touches / pressions).

Les widgets sont donc de bons moyens de réaliser des agrégateurs de contenus, mais fabriquer un petit gadget interactif (du type xEyes par exemple) est pour l'instant impossible compte tenu des restrictions de sécurité.

Tutorial : Les dossiers dynamiques ou Live Folder

Patrice — Wed, 06 May 2009 17:11:00 +0200

Un dossier dynamique est un raccourci sur le bureau qui affiche une liste ou une grille avec des informations dynamiques qui viennent d’une application. Cela peut être les derniers contacts appelés, les derniers favoris, etc …

Nous allons voir comment créer ces dossiers pour afficher nos derniers SMS. Pour cela, on va utiliser l’astuce décrite dans un précédent billet pour accèder aux SMS de l’application.

Il y a deux étapes, tout d’abord créer le dossier dynamique, enfin créer le contenu qui sera affiché.

Création du dossier Dynamique

La création d’un dossier dynamique est très simple, car cela fonctionne sur le système des Intent. Il faut commencer par créer une activité qui va s’occuper de créer ce dossier. Cette activité peut afficher des informations et en demander à l’utilisateur pour configurer le dossier. L’activité doit ensuite retourner un RESULT_OK en envoyant un Intent avec l’adresse du content provider pour afficher les données dans le champ Date et les paramètres du dossier dans les données extra :

LiveFolders.EXTRA_LIVE_FOLDER_NAME : Le nom du dossier
LiveFolders.EXTRA_LIVE_FOLDER_ICON : L’icône du fichier
LiveFolders.EXTRA_LIVE_FOLDER_BASE_INTENT : L’Intent a appeler lors de la sélection d’un élément de la liste
LiveFolders.EXTRA_LIVE_FOLDER_DISPLAY_MODE : Le type d’affichage qui peut être mis à LiveFolders.DISPLAY_MODE_LIST pour un affichage en liste, ou à LiveFolders.DISPLAY_MODE_GRID pour un affichage en grille

Voici donc une fonction très simple pour créer l'Intent à retourner :

L'uri est l'url du content Provider qui donnera les informations pour remplir le dossier et le baseUri est l'url de base auquel est concaténé l'Id de celui-ci pour accéder à l'élément lorsqu'on le sélectionne.

Voilà nous pouvons maintenant faire une activité qui va juste retourner cette Intent :

Il faut maintenant déclarer cette activité dans le AndroidManifest.xml, il faut pour cela ajouter l'action CREATE_LIVE_FOLDER dans la liste des intents-filters pour qu'elle soit reconnue par le système comme une activité qui crée un dossier dynamique.

Voilà, la création du dossier est finie, si vous installez cette application, et que vous allez sur la page d’accueil, et vous cliquez sur le menu puis sur l’option “Ajouter”(Add) ou un clic long sur le fond d’écran, vous avez l’entrée “Dossiers” (Folders) qui affiche ensuite la liste des dossiers dynamiques, vous verrez votre dossier. Votre application se lance et retourne tout de suite l’Intent que vous avez créé, et aussitôt votre dossier apparaît sur la page d’accueil. En l’ouvrant, votre dossier plantera, car il nous faut encore créer le content Provider.

Content Provider :

Notre dossier dynamique retourne l’url du contenu, lors de l’ouverture du dossier, android va faire une requête à notre content provider (SMSContentProvider). Ce content provider doit retourner deux colonnes : LiveFolders._ID qui contient l’id de l’élèment et LiveFolders.NAME qui contient le nom de l’élément. On peut aussi retourner LiveFolders.DESCRIPTION pour afficher un texte en dessous ou LiveFolders.ICON_RESSOURCE pour afficher une icône. Comme le content provider de l’application SMS d’android ne retourne pas ses colonnes, nous devons créer notre content provider et à l’intérieur de celui-ci faire appel au content provider de l’application SMS.

Voici donc le code principal de notre content Provider :

Le reste de la classe contient les méthodes vides d’ajout, de mise à jour, et de suppression du contenu qui ne servent pas pour notre application mais qui sont obligatoires pour implémenter l’interface ContentProvider.

La méthode principale est la méthode query, nous commençons par vérifier que l’uri match bien avec notre UriMatcher. Puis nous appelons la methode query sur le ContentResolver qui va nous permettre de récupérer les données depuis le content provider de l’application SMS. Nous renommons les colonnes par les colonnes demandées par android et trions les résultats par date décroissante. Le MergeCursor est là à cause d’une limitation avec les curseurs entre plusieurs processus.

Pour la colonne _ID, nous utilisons le numéro de téléphone au lieu de l’ID du SMS car il n’est pas possible d’ouvrir l’application SMS pour afficher un SMS par un ID. Nous contournons cela en ouvrant l’application pour écrire un SMS au numéro de téléphone, ce qui a la particularité d’afficher la conversation avec ce contact au dessus du champ de saisie.

Voilà, maintenant, vous pouvez installer et tester votre dossier dynamique qui affichera vos SMS triés du plus récent au plus ancien.

Android Cupcake : comment flasher le Dev Phone

Florent — Wed, 29 Apr 2009 13:04:00 +0200

Il existe depuis peu une version officielle de l’image système de Cupcake pour les HTC Dev Phone. La procédure de mise à jour est rapide, sans risque de blocage non récupérable et en plus conserve les applications que vous avez déjà installées ainsi que leurs données.

Sachez aussi que cette procédure est réversible.

Vous aurez besoin de deux archives zip à télécharger sur le site de HTC : http://www.htc.com/www/support/android/adp.html

ota-radio-2_22_19_26I.zip (Radio Image Android 1.5)
signed-dream_devphone-ota-147201.zip (Recovery Image 1.5)

La première étape est de mettre à jour le firmware radio :

Assurez-vous que la SDCard est bien connectée au téléphone, transférez la première archive (ota-radio-2_22_19_26I.zip) vers la SDCard et renommez-la en update.zip, voilà comment faire en ligne de commande :
- <ANDROID_SDK>\tools\adb -d push ota-radio-2_22_19_26I.zip /sdcard/update.zip
- <ANDROID_SDK>\tools\adb -d shell sync
Arrêtez le téléphone, puis démarrez-le en mode recovery en maintenant appuyé la touche Home.
Vous devriez avoir un écran à fond noir avec une icône contenant un point d’exclamation, effectuez la combinaison de touches ALT+L pour faire apparaître les options :
Vous pouvez ignorer l’erreur "Can’t open ...". Faites ALT+S, le firmware se met alors à jour. une fois la mise à jour terminée, redémarrez le téléphone avec Home+Back.
Le système n’est alors toujours pas mis à jour. Transférez la deuxième archive (signed-dream_devphone-ota-147201.zip) de la même façon que la première (vers /sdcard/update.zip), redémarrez le téléphone en mode recovery, ALT+L, ALT+S, puis Home+Back une fois la mise à jour terminée.
Le téléphone redémarre plusieurs fois, patientez un peu et vous aurez alors le nouveau système Android 1.5 (Cupcake).

Pour plus de détails sur les mises à jour, il existe un Google Groups dédié : http://groups.google.com/group/Android-DevPhone-Updating

Android 1.5 is here!

dgirard — Mon, 27 Apr 2009 21:01:00 +0200

Xavier Ducrohet

I am also happy to let you know that our partners at HTC have made available new system images to upgrade your Android Dev Phone 1 (ADP1) to Android 1.5. This new version (which is only available for the ADP1) is based on the Cupcake branch from the Android Open Source Project and corresponds to the system image of the Android 1.5 SDK, release 1. If you have questions about the process of updating your device, you can ask the mailing list that we've set up.

Android 1.5 is here!

Tutorial : Manipuler les contacts - STEP 1 : READ

Gregory — Mon, 27 Apr 2009 16:25:00 +0200

Voir, Modifier, Supprimer des contacts ! En Ajouter des nouveaux ! En importer dans votre application, en exporter depuis celle-ci... C'est ce que nous allons voir ici ! Au final on obtiendra quelque chose comme ça : Le nom, le numéro, et la photo de chacun de vos contacts. Pour cette première partie, on commencera par "LIRE" les contacts.

ÉTAPE 1 : Récupérer les informations du contact...
...Et les afficher !

On utilisera donc pour cette première étape une simple liste qui affichera du texte a chaque item. Le nom et numéro de chaque contacts seront stockés dans une String. Le tableau contenant tout ce petit monde s'appelle donc contacts :

private ArrayList<String> contacts;
setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, contacts));

Lorsqu'on récupérera les contacts, on voudra le nom et le numéro (pour l'instant).

ContentResolver resolver = this.getContentResolver(); crée une instance de ce qui permet d'accèder au contenu d'autres application.

Uri uri = Contacts.People.CONTENT_URI; récupère l'URI où se trouvent vos contacts (on aurai aussi pu faire un parse de la string “content://contacts/people/”

String projection = new String {People.NAME, People.NUMBER }; est un tableau qui permettra de ne demander que les informations des colonnes indiquée. Cela permet d'éviter une requête trop importante.

Cursor cur = resolver.query(uri, projection, null, null, null); un Cursor correspond au résultat d'une requête sur base de donnée. Ici on récupère le résultat d ela requête sur l'uri des contact, avec comme seule colonnes demandée celles indiquée par projection. Les arguments supplémentaire placés ici à null permettent de faire l'équivalent des WHERE clause et ORDER BY des requêtes SQL classiques.

this.startManagingCursor(cur); est votre ami. Il s'occupe de fermer et rouvrir le curseur pour vous en fonction de l'état de votre Activity.

On à ici une liste basique, mais somme toute assez peu attrayante. Afin de pouvoir Afficher plus d'informations, vous devrez peu à peu vous diriger vers la solution d'utiliser votre propre adapteur, et votre propre layout générique.

ÉTAPE 2 : Récupérer plus d'information ! et les afficher mieux ;)

On crée donc notre propre layout : contact.xml, et notre propre adapteur : MyAdapter. On en profite pour créer notre propre classe de Contact pour y insérer/récupérer les données que l'on veux. Le changement de code de la classe principal est donc minime. setListAdapter(new MyAdapter(this, contacts)); remplace la ligne précédante. Et dans notre fonciton getContacts on change aussi l'ajout dans le tableau par : contacts.add(new Contact(name, num));

Le résultat est déjà un peu plus sympathique, et vous voyez déjà l'emplacement pour la prochaine partie : La photo !

ETAPE 3 : La photo C'est en réalité d'une simplicité déconcertante :

D'abord on récupère l'uri du contact concerné.
Puis on récupère simplement sa photo via : Bitmap img = People.loadContactPhoto(this, uri, R.drawable.icon, null);

Cette fois ci on utilisera l'autre méthode pour composer l'uri :

String id = cur.getString(cur.getColumnIndex(Contacts.People._ID)); uri = Uri.parse("content://contacts/people/" + id);

Il suffit ensuite d'ajouter cette photo dans votre objet Contact, puis de le faire afficher dans l'adapter :

La source complète du code est disponible en pièce jointe

Market Place Android et France

dgirard — Sat, 25 Apr 2009 01:30:00 +0200

La market place Android permet maintenant de déployer uniquement sur la France.

ZXing : Comment tester le scan de code QR sur l’émulateur

Florent — Thu, 23 Apr 2009 16:28:00 +0200

La semaine dernière (Tutorial : Scanner et générer des codes QR (2D) sur Android), nous avons vu comment faire appel à l’application Barcode Scanner afin de décoder un code QR. Barcode Scanner ne propose que l’appareil photo pour la capture de l’image du code, ce qui le rend inutilisable sur l’émulateur.

Il est possible en utilisant JMF et une connection TCP/IP émulateur/hôte de simuler l’appareil photo avec la Webcam (expliqué ici) mais cela n’est pas pratique pour nos besoins.

La solution retenue est de créer une nouvelle activité de scan qui prend en paramètre une image présente sur la sdcard. Pour ce faire, il vous faudra :

Créer une image de sdcard et la monter dans l’émulateur (expliqué ici) ;
Charger des images de codes QR (format png ou jpeg) sur cette sdcard (voir lien précédent) ;
Créer une IntentFilter qui aura la même action que l’activité de scan de ZXing :

<activity android:name="ScanFileActivity">

  <intent-filter>

    <action android:name="com.google.zxing.client.android.SCAN"
/>

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

  </intent-filter>

</activity>

Ainsi, lorsqu’une Intent avec cette action sera soumise, le système Android proposera une liste déroulante des applications capables de les traiter.

Ensuite il faut créer la classe de l’activité ScanFileActivity. L’écran de cette activité affichera une liste des images présentes sur la SDCard et lorsque l’une d’entre elles sera choisie, un objet QRcodeReader est instancié dans un thread avec les données de l’image en paramètre. Cette classe de la bibliothèque ZXing prend en paramètre un objet MonochromeBitmapSource adapté à la classe Bitmap d’Android via la classe RGBMonochromeBitmapSource
La classe ScanFileActivity renvoie un résultat en respectant le même format que CaptureActivity (classe de Barcode Scanner). Du coup, il n’y aucun changement à faire sur l’activité principale écrite lors du précédent article.

Cette nouvelle activité n’étant pas utile sur un vrai téléphone, il faudra alors commenter sa déclaration dans le fichier AndroidManifest.xml ou l’isoler dans une application à part.

En conclusion, ce billet montre une fois de plus la force des Intent dans la plateforme Android.

Vous trouverez les sources des fichiers mentionnés dans cet article ici : http://code.google.com/p/zxing/source/checkout

HiveLayout et Android 3 : La Cellule (et les sources).

Adrien — Wed, 22 Apr 2009 17:36:00 +0200

Après le HiveLayout vu précédemment, il nous manque toujours des HiveCells à ajouter pour obtenir notre affichage complet. Il s'agit ici de trouver un moyen efficace de dessiner l'Hexagone et de gérer les clics à l'intérieur de sa zone, et d'ajouter du contenu à l'intérieur de l'Hexagone. Et surtout, c'est l'occasion de vous donner des sources d'un projet qui met en œuvre l'aspect théorique :)

Ce billet fait suite à http://www.insideandroid.fr/post/2009/04/15/Android-%3A-Creation-d-un-HiveLayout-premiere-etape

Nous disposons donc maintenant de notre HiveLayout et d'un système permettant d'ajouter nos cellules au bon endroit, mais il nous faut encore créer lesdites cellules.

On va donc étendre une View. Il faut commencer par définir la zone qu'occupera la cellule en surchargeant la méthode onMeasure.
On sait que l'hexagone est contenu dans un carré de largeur 2*size et de hauteur calculée précédemment (2*halfHeight).

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(measureWidth(widthMeasureSpec),
                measureHeight(heightMeasureSpec));
    }

    private int measureWidth(int measureSpec) {
        return 2 * size;
    }

    private int measureHeight(int measureSpec) {
        int height = 2 * ((int) Math.sqrt((double) (size * size - (size / 2)
                * (size / 2))));
        return height;
    }

Maintenant que l'on dispose de notre surface de dessin, nous allons créer le contour en utilisant le Path suivant :

        Path path = new Path();
        path.moveTo(size / 2, 0);
        path.lineTo(0, halfHeight);
        path.lineTo(size / 2, 2 * halfHeight);
        path.lineTo(size * 3 / 2, 2 * halfHeight);
        path.lineTo(size * 2, halfHeight);
        path.lineTo(size * 3 / 2, 0);
        path.lineTo(size / 2, 0);
        path.close();

On peut vérifier si le point est bien à l'intérieur de l'hexagone avec la fonction suivante :

    public boolean checkPointInside(float x, float y) {
        if (y < (-(halfHeight * 2) / size) * x + halfHeight)
            return true;
        if (y > ((halfHeight * 2) / size) * x + halfHeight)
            return true;
        if (y > (-(halfHeight * 2) / size) * x + 5 * halfHeight)
            return true;
        if (y < ((halfHeight * 2) / size) * x - 3 * halfHeight)
            return true;
        return false;
    }

Et on dessine la cellule de la manière suivante :

    protected void onDraw(Canvas canvas) {
        canvas.clipPath(path);
        canvas.drawColor(0xFFFF0000);
    }

Ce sont les bases nécessaires à l'affichage et l'utilisation optimale de nos cellules, mais ce n'est qu'une base, il reste beaucoup à faire.

Pour utiliser ce layout, vous pourrez par exemple vouloir associer vos objects à une cellule, mettre en place un système de configuration xml pour les cellules, etc...

Les sources d'un exemple sont fournies en pièce jointe, avec thème XML, gestion du touch sur la cellule et menu pour ajouter des séries de cellules.

Tutorial : Scanner et générer des codes QR (2D) sur Android

Florent — Fri, 17 Apr 2009 06:00:00 +0200

Vous avez une idée d’application s’appuyant sur les codes QR ? ZXing vous permettra de la réaliser (presque) sans effort !

En effet, l’une des principales forces d’Android est de pouvoir réutiliser des fonctionnalités déjà implémentées par des applications existantes. Le principe est de créer des objets Intent qui vont cibler l’application implémentant la fonction qui nous intéresse, éventuellement de lui passer des paramètres (méthode «putExtra») et de faire appel à l’activité capable de répondre à ce besoin en utilisant «startActivityForResult». Cette dernière renverra une réponse sous forme d’un objet Intent passé en paramètre à «onActivityResult». Je ne m’étenderai pas plus à ce sujet (plus d’infos ici: http://developer.android.com/guide/topics/fundamentals.html#actcomp).

Le projet ZXing (se prononce «Zebra Crossing») est un ensemble de bibliothèques et d’applications de lecture de code-barres visant un large spectre de plateformes : Java SE /Java ME, C++, C#, iPhone, Blackberry, … et bien sûr Android :).

L’ensemble du projet est à télécharger à cette adresse:

http://code.google.com/p/zxing/downloads/list

Les scripts Ant vous permettront de générer une version optimisée de l’application :

Pour cela, vous aurez besoin de Ant (http://ant.apache.org) et de Proguard (http://sourceforge.net/project/showfiles.php?group_id=54750&package_id=49483). Dézippez l’archive de proguard et copier-collez «lib\proguard.jar» dans «bin».

Puis dans le répertoire de ZXing, d’abord dans «core» qui contient les fonctions de reconnaissance/génération des codes-barres :

ant -f build.xml build-no-debug

Dans «android» :

ant -f build.xml -Dandroid-home=«racine du SDK android» -DWTK-home=«racine du répertoire de proguard»

Lancez l’émulateur («android SDK»\tools\emulator). Et finalement, installez l’application avec la commande suivante :

ant -f build.xml install -Dandroid-home=«racine du SDK android»

Vous devriez alors trouver une application «Barcode Scanner» dans l’émulateur.

Vous ne pourrez malheureusement pas la tester pleinement dans l’émulateur (Nous vous apprendrons dans un autre billet à utiliser une Webcam depuis l’émulateur), mais sachez que cette application est capable de partager vos contacts/favoris via code QR, rechercher des produits grâce à leur code-barre, etc.

Maintenant créez un nouveau projet Android, changez le layout main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<Button
    android:id="@+id/scanButton"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="Click to scan"
    />
</LinearLayout>

Et remplacez le code de votre activité par:

private static final int REQUEST_SCAN = 0;
 
 
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    Button btScan = (Button)
this.findViewById(R.id.scanButton);
    btScan.setOnClickListener(btScanListener);
}
 
private Button.OnClickListener btScanListener = new
Button.OnClickListener() {
    public void onClick(View v) {
        Intent intent = new
Intent("com.google.zxing.client.android.SCAN");
        intent.putExtra("SCAN_MODE",
"QR_CODE_MODE");
 
 
        try {
         
startActivityForResult(intent, REQUEST_SCAN);
       } catch (ActivityNotFoundException
e) {
         Toast.makeText(Main.this,
"Barcode Scanner ne semple pas être installé", 2000).show();
       }
    }
};
 
public void onActivityResult(int reqCode, int resCode, Intent
intent) {
    if (REQUEST_SCAN == reqCode) {
        if (RESULT_OK == resCode) {
            String contents =
intent.getStringExtra("SCAN_RESULT");
            Toast.makeText(this,
"Succès : " + contents, 2000).show();
        } else if (RESULT_CANCELED ==
resCode) {
            Toast.makeText(this,
"Scan annulé", 2000).show();
        }
    }
}
 
 

Lancez votre projet dans l’émulateur, cliquez sur le bouton, puis à défaut de pouvoir scanner, appuyez sur le bouton «Back», le message «scan annulé» devrait alors s’afficher, nous indiquant que «Barcode Scanner» nous a bel et bien renvoyé un résultat.

L’aspect visuel n’est certes pas spectaculaire, mais constatez que notre application n’a aucune dépendance en terme de code vis-à-vis de «Barcode Scanner», ce qui est topissime !

Si Barcode Scanner n’est pas présent dans l’émulateur, alors l’exception ActivityNotFoundException est levée. Une classe IntentIntegrator (http://code.google.com/p/zxing/source/browse/trunk/android-integration/src/com/google/zxing/integration/android/IntentIntegrator.java) est à votre disposition pour générer l’Intent de scan qui vous permet de réduire le code émettant une Intent à:

IntentIntegrator.initiateScan(Main.this);

De plus, cette méthode propose le cas échéant de télécharger Barcode Scanner depuis la Marketplace Android (ne fonctionne que sur un vrai téléphone).

Pour générer un code QR, l’Intent à créer est la suivante:

Intent intent = new Intent("com.google.zxing.client.android.ENCODE");
intent.putExtra("ENCODE_DATA", “votre message”);
intent.putExtra("ENCODE_TYPE", "TEXT_TYPE");

Les types de contenu que vous pouvez encoder sont dans la classe com.google.zxing.client.android.Contents.Type.

Vous trouverez les sources complètes de ma démo ici : http://code.google.com/p/example-zxing/source/checkout