Vérifier la connectivité sur Android

Introduction

Une fois n’est pas coutume, nous allons parler d’Android ! Et plus particulièrement de vérifier si l’utilisateur est oui ou non connecté à Internet. En effet, certains scénarios peuvent exiger que vous fassiez une vérification avant une opération. Par exemple, récupérer des données depuis un cache local si les données ne peuvent être téléchargées.

 

Permission

La première étape consiste à ajouter la permission android.permission.ACCESS_NETWORK_STATE dans notre manifest

<uses-permission android:name=android.permission.ACCESS_NETWORK_STATE />

Le code

Le code est relativement simple. La première étape consiste à récupérer le ConnectivityManager depuis le contexte.

ConnectivityManager connectivityManager = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);

Ensuite, on récupère les informations liées au réseau, situées dans la classe NetworkInfo, et l’on vérifie si l’objet récupéré n’est pas null.

NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
if (networkInfo != null)

On récupère ensuite dans la condition l’état du réseau, et on vérifie si le device est connecté.

if (networkInfo != null)
{
    State networkState = networkInfo.getState();
    if (networkState.compareTo(State.CONNECTED) == 0)
    return true;
}
return false;

Voici le code final dans une méthode statique :

public static boolean isConnected(Context context)
{
    ConnectivityManager connectivityManager = (ConnectivityManager) context
    .getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
     if (networkInfo != null)
    {
        State networkState = networkInfo.getState();
        if (networkState.compareTo(State.CONNECTED) == 0)
        return true;
    }
    return false;
}

 

Vous pouvez retrouver cette méthode dans la classe NetworkHelper de mes tools pour Android, sur Github : https://github.com/Neferetheka/Helper-Tools-for-Android

Share Button

Windows 8 : Bing Maps et l’API Foursquare en 15 minutes

Introduction

La toute dernière mise à jour de Visual Studio 11 a vu l’ajout de templates d’applications utilisant le contrôle Bing Maps pour Windows 8. Un contrôle existait déjà auparavant, mais son utilisation est désormais grandement simplifiée. Je vous propose donc de voir comment l’on peut utiliser ce contrôle, aux côtés de l’API Foursquare. Ainsi, nous allons localiser l’utilisateur sur une carte, et ensuite lui proposer la liste des lieux intéressants aux alentours.

 

Création du projet

La première étape consiste à créer votre application. Pour cela, rien de plus simple, puisque Visual Studio nous propose le template « Bing Maps Application ». Vous n’avez qu’à le sélectionner, et le projet sera configuré automatiquement.

Si ce template n’apparait pas dans la liste, veillez à avoir la dernière mise à jour de Visual Studio.

Création du projet

 

Indiquer votre clé d’API Bing Maps

Vous devriez avoir une nouvelle page créée, nommée “BlankPage.xaml”. Ouvrez-là, et trouvez le code suivant :

<bm:Map Grid.Column="0" x:Name="map"
     MapType="Road" ZoomLevel="12" Credentials="" >
     <bm:Map.Center>
          <bm:Location Latitude="47.62" Longitude="-122.19" />
     </bm:Map.Center>
</bm:Map>

Il ne vous reste plus qu’à renseigner vos Credentials Bing Maps. Si vous lancez l’application vous devriez avoir une map toute simple :

Bing Maps

Récupérer la position

A présent que nous avons notre carte prête à l’affichage, il nous faut récupérer la position de notre utilisateur. Pour cela il nous faut avant tout ajouter la permission dans le manifest de l’application. Sans cela, nous n’aurons pas accès à la localisation. Cochez donc la case Location.

manifest

 

 

 

 

 

 

 

 

 

 

A présent, nous pouvons commencer à coder véritablement. Allons dans le fichier BlankPage.xaml.cs, et commençons par ajouter deux attributs :

Geolocator geo = new Geolocator();

Location actualLocation;

Si vous avez déjà travaillé sur Windows Phone 7, ces deux classes vous sont peut-être familières. La première permet d’obtenir la localisation, tandis que la seconde permet de stocker des emplacements, sous forme de latitude, longitude etc.

Vous pouvez, si vous le souhaitez, améliorer la précision de la localisation en changeant l’attribut DesiredAccuracy de l’objet Geolocator, de la manière suivante :

public BlankPage()
{
    this.InitializeComponent();
    geo.DesiredAccuracy = PositionAccuracy.High;
}

Ensuite, il nous faut créer une méthode permettant de récupérer la localisation à partir de notre GeoLocator. Pour cela, notre méthode se doit d’être asynchrone. Si vous n’êtes pas à l’aise avec l’asynchronisme sur Windows 8, vous pouvez consulter cet article .

La méthode à utiliser sur notre objet GeoLocator est GetGeopositionAsync. Nous pouvons, à partir du résultat, créer notre objet Location.

var currentPosition = await geo.GetGeopositionAsync();

actualLocation = new Location()
{
	Latitude = currentPosition.Coordinate.Latitude,
	Longitude = currentPosition.Coordinate.Longitude
};

N’oubliez pas de rendre votre méthode async.

Dernière étape, faire pointer notre carte sur notre localisation. Pour cela, il faut invoquer la méthode SetView de notre objet Bing Maps, en lui passant notre objet Location et un niveau de zoom. Vous pouvez ajouter un booléen pour animer le changement de vue.

map.SetView(actualLocation, 20, true);

Vous n’avez plus qu’à appeler la méthode pour mettre à jour la position (dans OnNavigatedTo par exemple).

Requêter l’API Foursquare

Afin d’exploiter l’API Foursquare, vous pouvez consulter mon article sur son utilisation sur Windows Phone 7. Les traitements sont les mêmes. Vous n’avez qu’à modifier la partie WebClient par un HttpClient de la manière suivante :

string v = String.Format("{0:yyyyMMdd}", DateTime.Now);

string url = FoursquareManager.URLAPI + "ll=" + actualLocation.Latitude.ToString().Replace(",", ".") + "," +
	actualLocation.Longitude.ToString().Replace(",", ".") + "&client_id=" +
	FoursquareManager.CLIENTID + "&client_secret=" + FoursquareManager.CLIENTSECRET + "&v=" + v;

HttpClient client = new HttpClient();
string response = await client.GetStringAsync(url);
List<Venue> listVenues = FoursquareManager.LoadVenuesFromJson(response);

Vous obtenez ainsi une liste de Venues proches de l’utilisateur.

Faire un template de la listview

La dernière étape consiste à réaliser un affiche de nos différents venues, au moyen d’une ListView. Nous retournons donc côté XAML, et commençons par ajouter des colonnes à notre Grid principal.

<Grid.ColumnDefinitions>
     <ColumnDefinition Width="*" />
     <ColumnDefinition Width="300"/>
</Grid.ColumnDefinitions>

Nous placerons la carte sur la première colonne, et la ListView dans la seconde, avec une largeur donc de 300 pixels. Nous créons ensuite la ListView

<ListView x:Name="listViewVenues" Grid.Column="1" Background="White"></ListView>

Si vous testez en l’état, vous remarquerez que l’affichage n’est pas des plus heureux. Nous ajoutons donc un template sur nos éléments :

<ListView.ItemTemplate>
     <DataTemplate>
          <StackPanel Orientation="Horizontal" Margin="5">
               <Image Source="{Binding Path=Image}" />
               <TextBlock Margin="10,0,0,0" Text="{Binding Path=Name}" Foreground="Black"/>
          </StackPanel>
     </DataTemplate>
</ListView.ItemTemplate>

N’oubliez pas de mettre votre liste de venues en ItemsSource

listViewVenues.ItemsSource = listVenues;

Et voici le résultat final :

 

Le résultat final

Conclusion

Le partage de code entre Windows Phone 7, couplé à la puissance de WinRT nous permet de construire très rapidement et très simplement des applications relativement avancées. A partir d’une carte et d’une liste de lieux à proximité, les possibilités offertes sont nombreuses.

Vous pouvez trouver tout le code de cette application à l’adresse suivante : https://github.com/Neferetheka/MiniFoursquareForWindows8

Share Button

Windows 8 : faire une toast notification

Introduction

Vous l’avez sans doute remarqué, dans le framework .NET 4.5, la célèbre classe MessageBox, telle que nous la connaissions, a disparue.

Mais alors comment afficher des messages à notre utilisateur ?

Premièrement, il faut savoir qu’une boite de dialogue modale (qui bloque le reste de l’application) est généralement déconseillée. En effet, elle perturbe l’utilisateur dans son utilisation de l’application. Le mieux donc reste de notifier simplement l’utilisateur de quelque chose, sans pour autant le bloquer. C’est le principe de la Toast Notification de Windows 8. Le résultat final donne une petite fenêtre sur le côté de l’écran, que l’utilisateur peut fermer à la main. Sinon, elle disparait petit à petit.

Le code

Le code pour effectuer une Toast Notification est des plus simples. De plus, de nombreuses options sont disponibles, comme par exemple ajouter une image. Nous nous contenterons ici d’un texte simple. Le tout se configure grâce à un XML.

public static void ToastAlert(string message)
{
	XmlDocument toastXml = ToastNotificationManager.
   GetTemplateContent(ToastTemplateType.ToastText01);

	XmlNodeList textElements = toastXml.GetElementsByTagName("text");
	for (int i = 0; i < textElements.Length; i++)
	{
		textElements.Item(i).AppendChild
			 (toastXml.CreateTextNode(message));
	}

	ToastNotification toast = new ToastNotification(toastXml);
	ToastNotificationManager.CreateToastNotifier().Show(toast);
}

 

N’oubliez pas non plus d’activer les Toast Notifications dans le manifest :

toast-manifest

 

 

 

 

Et voilà le résultat final :

Un exemple de toast sur GeoWarfare

Share Button

Effectuer une requête http sur Windows 8

Introduction

Si vous êtes un habitué du framework .NET, vous connaissez sans doute la classe WebClient. Je l’ai moi-même utilisé plusieurs fois au cours de mes articles et de mes projets. Néanmoins, avec l’arrivée de Windows 8 et du framework .NET 4.5, cette classe a disparue. En effet, certaines actions (dont les requêtes http) fonctionnent maintenant de manière asynchrone. Adieu donc WebClient, bonjour HttpClient.

 

Le modèle asynchrone

Au sein du framework .NET 4.5, deux nouveaux mots-clés très importants ont fait leur apparition : await et async. Le premier permet de définir automatiquement un comportement asynchrone et d’attendre pour un résultat. Le second permet de définir qu’une méthode peut effectuer du code asynchrone (et donc utiliser await par exemple).

Je vous conseille cette session de la Build pour en savoir plus sur le sujet : http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-810T

Nous verrons un cas concret de l’utilisation de ces deux mots-clés un peu plus loin.

 

Effectuer une requête http pour récupérer une chaine de caractères

Comme dit précédemment, nous allons utiliser la classe HttpClient afin d’effectuer une requête http. Le but ici va être de récupérer une simple chaine de caractère, quel qu’en soit le format (plain text, json, xml etc.). Le tout doit bien entendu être fait de manière asynchrone !

Commençons donc par déclarer une méthode. Puisque du traitement asynchrone va y être effectué, nous lui ajoutons le mot-clé async.

private async void LoadDatas()

Ensuite, nous créons une nouvelle instance de HttpClient, et nous utilisons sa méthode GetStringAsync, qui prend en paramètre une simple chaine de caractère pour l’url. Et oui, fini les objets Uri pour nos requêtes !

Néanmoins, puisque la requête va se faire de manière asynchrone, il nous faut utiliser le mot clé await devant la méthode, de la manière suivante :

HttpClient client = new HttpClient();
string response = await client.GetStringAsync("http://www.google.fr");

Plutôt simple non ?

 

Conclusion

Bien que l’exemple utilisé ici n’implique qu’une simple chaine de caractères à récupérer, l’utilisation est simplifié par rapport au WebClient et gère un grand nombre de scénarios. L’asynchronisme est vraiment un plaisir à utiliser, et évite les blocages de l’UI. N’oubliez donc pas, pensez async !

Share Button

Windows 8 : Naviguer au sein d’une frame

Lorsque vous créez une application Windows 8 en XAML, il est possible que vous utilisiez une Frame, afin de naviguer entre les écrans. Pour ce faire, il suffit d’appeler la méthode Navigate.

Cependant, alors qu’en Silverlight 4, cette méthode prenait en argument une Uri, elle a changé dans Windows 8. De plus, il y a des différences entre la Developer Preview et la Consumer Preview.

Je vous fournit donc ici le code à utiliser suivant la situation (ici, pour une page XAML nommée Home.xaml).


En Silverlight

frame.Navigate(new Uri("Home.xaml"));

Windows 8 Developer Preview

frame.Navigate(typeof(Home).FullName);

Windows 8 Consumer Preview

frame.Navigate(typeof(Home));



Windows 8

Share Button

Exploiter l’API Venues de Foursquare sur Android

Introduction

Après avoir vu comment exploiter l’API Venues de Foursquare sur Windows Phone 7, je vous propose de découvrir son utilisation sur Android. Si le traitement reste à peu près le même, les manières de faire sont parfois différentes.

 Powered By Foursquare

Détails de l’API

Au cas où vous ne sauriez pas ce qu’est Foursquare, ou comment accéder à l’API, je vous renvoie à mon précédent article.

 

Créer le modèle de données

Tout comme sur Windows Phone 7, nous allons commencer par créer une classe qui contiendra nos données. Notez qu’ici les attributs sont en public par souci de lisibilité. Vous pouvez tout à fait utiliser des attributs privés avec des getters/setters.

public class Venue
{
     public String Name;
     public String Adress = "";
     public String City = "";
     public int Distance = 0;
     public String Image;

 

Afin de récupérer les attributs City, Distance et Image, nous allons, comme sur WP, nous allons parser le Json renvoyé par l’API. Pour cela, nous aurons besoin des imports suivants :

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

 

Et le code du constructeur :

public Venue(String name, JSONObject location, JSONArray categories) throws JSONException
{
	Name = name;

	if (location.has("address"))
		Adress = location.getString("address");
	if (location.has("city"))
		City = location.getString("city");
	if (location.has("distance"))
		Distance = Integer.parseInt(location.getString("distance"));

	if (categories.length() > 0)
	{
		Image = categories.getJSONObject(0).getJSONObject("icon").getString("prefix") + "64.png";
	}
	else
		Image = "";
}

Il s’agit d’une simple utilisation de l’API Json d’Android. Notez que les exceptions sont renvoyées au niveau au-dessus (dans la méthode qui construira l’objet).

 

Gérer la liste des Venues

Avant de gérer les résultats renvoyés par l’API, nous allons créer une classe abstraite nommée FoursquareManager.

public abstract class FoursquareManager

Nous lui ajoutons les attributs nous permettant d’accéder à l’API :

private static final String urlApi = "https://api.foursquare.com/v2/venues/search?";
private static final String CLIENTID = "monId";
private static final String CLIENTSECRET = "monSecret";

 

On utilise ensuite une méthode static pour parser nos résultats et les ajouter à une liste de Venues.

public static List<Venue> getVenuesAroundMe(double latitude, double longitude)
{
     List<Venue> listVenues = new ArrayList<Venue>();

 

L’API Foursquare nous demande un argument v qui correspond à la date du jour. Nous l’obtenons avec un SimpleDateFormat :

Date date= new Date();
DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
String v = dateFormat.format(date);

Il va nous falloir ensuite réaliser une requête http pour aller exploiter l’API. Pour cela, nous utilisons la classe DefaultHttpClient. Si vous voulez en savoir plus sur son utilisation, je vous renvoie à la documentation : http://developer.android.com/reference/org/apache/http/impl/client/DefaultHttpClient.html

 

String result = httpRequest(urlApi + "ll="+latitude + "," + longitude+"&client_id="+CLIENTID+"&client_secret="+CLIENTSECRET+"&v="+v);

 

Il ne reste plus ensuite qu’à parser le Json :

JSONObject jsonReponse;
try
{
	jsonReponse = new JSONObject(result);
	JSONArray array = jsonReponse.getJSONObject("response").getJSONArray("venues");
	for (int i = 0; i < array.length(); i++)
	{
		JSONObject json = array.getJSONObject(i);
		try
		{
			listVenues.add(new Venue(json.getString("name"),
					json.getJSONObject("location"),
					json.getJSONArray("categories")
					));
		}
		catch (Exception e)
		{
			Log.e("Foursquare", "Erreur de parse du json Foursquare : " + e.getMessage());
		}
	}
}
catch (Exception ex)
{
	ex.printStackTrace();
}

return listVenues;

 

Conclusion

Ici, le traitement de la requête http a été réalisé directement dans la classe FoursquareManager afin de simplifier au maximum l’utilisation de la classe et de se concentrer sur l’exploitation des résultats.

Et avec un peu de travail, voilà ce que vous pouvez obtenir :

Foursquare

Share Button

Exploiter l’API Venues de Foursquare sur Windows Phone 7

Introduction

Si vous développez une application de géolocalisation, il vous est certainement arrivé de vouloir proposer à l’utilisateur la liste des points d’intérêt (POI) qui l’entourent. Bien qu’il soit possible de récupérer une telle liste via un service Bing sur Windows Phone, les résultats sont assez limités et ne peuvent concerner qu’une certaine partie des POI (les restaurants par exemple).

Je vous propose donc d’utiliser l’API Foursquare, très bien réalisée et documentée, et qui permet justement d’avoir accès à des informations très précises sur ces fameux POI !

 

Powered By Foursquare

 

Foursquare pour les nuls

Peut-être ne savez-vous pas ce qu’est Foursquare ? Je vous donne donc la définition de ce réseau social qui est donnée sur le site web :

Foursquare sur GeoWarfare

Un exemple d'application utilisant Foursquare

Foursquare facilite ton quotidien. Nous développons des outils qui te permettent de rester en contact avec tes amis, de savoir ce qu’il se passe près de chez toi, d’économiser de l’argent et de bénéficier d’offres spéciales. Qu’il s’agisse de partir pour un tour du monde, d’organiser une soirée entre amis ou de déguster le meilleur plat dans un restaurant, foursquare est le compagnon idéal.

En somme, Foursquare vous propose d’arpenter le monde et d’explorer les lieux qui vous entourent, de réaliser des check-in et de les partager avec vos amis. A la fois donc un jeu, un moyen de trouver des endroits sympas, mais aussi de se retrouver entre amis. Vous avez envie d’un cupcake ? Foursquare saura vous trouver un endroit où en manger !

Mais pour les développeurs, Foursquare propose surtout une API très complète (écrite en Scala), et qui permet, entre autre, de récupérer les fameux POI (Venues) correspondants à une localisation.

 

 

Détails de l’API

La première étape consiste à vous créer un compte Foursquare, puis de vous rendre à cette adresse :

https://developer.foursquare.com/

Vous devrez ensuite vous rendre dans la section My Apps et créer un nouveau Consumer (une application en somme). Vous obtiendrez ainsi un ClientId et un ClientSecret, requis pour utiliser l’API Venues.

Vous pouvez avoir plus d’informations sur cette API à cette adresse :

https://developer.foursquare.com/overview/venues

Et voir le format du résultat ici :

https://developer.foursquare.com/docs/explore

Comme vous pourrez le constater, le format du résultat est en json. Nous utiliserons donc la librairie NewtonsoftJson disponible à l’adresse suivante :

http://json.codeplex.com/

 

Créer le modèle de données

La première étape va consister à créer une classe qui contiendra nos résultats. Ici, il vous faudra quelles informations vous seront utiles ou non. En effet, l’API renvoie de nombreuses informations, dont certaines ne vous serviront peut-être pas !

Voici un exemple de ce que vous pourriez vouloir utiliser :

public class Venue
{
     public string Name { getset; }
     public string Address { getset; }
     public string City { getset; }
     public int Distance { getset; }
     public string Image { getset; }
}

Si vous analysez les réponses de l’API Foursquare, vous verrez que pour récupérer City, Distance et Image, il faut récupérer des nœuds enfants. Mon constructeur est donc un peu particulier puisqu’il va aller chercher ces informations.

public Venue(JToken location, JToken categories)
{
     if (location.SelectToken("address") != null)
          Address = location["address"].ToString();
     else
          Address = string.Empty;
     if (location.SelectToken("city") != null)
          City = location["city"].ToString();
     else
          City = string.Empty;
     if (location.SelectToken("distance") != null)
          Distance = Convert.ToInt32(location["distance"].ToString());
     else
          Distance = 0;

 

Concernant l’image, elle n’est pas toujours présente (en réalité, il s’agit de l’image de la catégorie. Si le lieu n’en possède pas, il n’y a pas d’image !). Il faut donc vérifier si elle existe ou non.

if (categories.HasValues)
{
     Image = categories.First["icon"]["prefix"].ToString() + "64.png";
}
else
     Image = string.Empty;

Le code final du modèle est donc :

public Venue(JToken location, JToken categories)
{
	if (location.SelectToken("address") != null)
		Address = location["address"].ToString();
	else
		Address = string.Empty;
	if (location.SelectToken("city") != null)
		City = location["city"].ToString();
	else
		City = string.Empty;
	if (location.SelectToken("distance") != null)
		Distance = Convert.ToInt32(location["distance"].ToString());
	else
		Distance = 0;

	if (categories.HasValues)
	{
		Image = categories.First["icon"]["prefix"].ToString() + "64.png";
	}
	else
		Image = string.Empty;
}

 

 

Gèrer la liste des Venues

Afin de gérer de manière efficace la liste des lieux reçus, il est préférable de créer une classe à part spécialement conçue pour cela. Elle aura pour but de parser le json reçu pour le convertir en une liste de venues, conformément au modèle ci-dessus.

On commence par créer une classe (abstract, puisque l’on se servira d’une unique méthode statique).

 public abstract class FoursquareManager

 

On va ensuite définir trois constantes importantes. La première nous servira de base pour construire l’URL vers l’API. Les deux autres correspondront à vos identifiants auprès de l’API Foursquare (Les fameux ClientID et ClientSecret).

 

public const string URLAPI = "https://api.foursquare.com/v2/venues/search?";
public const String CLIENTID = "MONID";
public const String CLIENTSECRET = "MONSECRET";

 

Ensuite, il ne reste plus qu’à écrire la méthode qui va parser le json, et construire à partir de là nos venues.

public static List<Venue> LoadVenuesFromJson(string result)
{
	List<Venue> listVenues = new List<Venue>();

	//On parse le json et on sélectionne toutes les venues
	JObject json = JObject.Parse(@result);
	var venues = json["response"].SelectToken("venues");

	foreach (JToken venue in venues)
	{
		try
		{
			//On passe le noeud location et le noeud categories, conformément au constructeur
			listVenues.Add(new Venue(venue["location"], venue["categories"])
			{
					Name = venue["name"].ToString(),
			});
		}
		catch (Exception ex)
		{
			Debug.WriteLine(ex.Message);
		}
	}

	return listVenues;
}

 

Requêter l’API

Maintenant qu’on dispose de notre modèle et de quoi le créer, il ne reste plus qu’à requêter l’API Foursquare !

La première étape est de récupérer la date actuelle au format yyyyMMdd. Pourquoi ? Parce que l’API Foursquare le requiert.

string v = String.Format("{0:yyyyMMdd}", DateTime.Now);

 

On construit ensuite l’url à requêter en précisant longitude et latitude.

string url = FoursquareManager.URLAPI + "ll=" + lat.ToString().Replace(",", ".") + "," + lon.Replace(",", ".") + "&client_id=" + FoursquareManager.CLIENTID + "&client_secret=" + FoursquareManager.CLIENTSECRET + "&v=" + v;

 

Notez que Foursquare accepte les coordonnées au format américain, donc avec des points au lieu des virgules pour les nombres à virgules flottantes.

On envoie ensuite notre requête via un simple Webclient.

 
WebClient client = new WebClient();
client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(SharePositionClickCompleted);
client.DownloadStringAsync(new Uri(url, UriKind.Absolute));

 

Et on récupère le résultat ensuite :

void SharePositionClickCompleted(object sender, DownloadStringCompletedEventArgs e)
{
     List<Venue> listeVenues = FoursquareManager.LoadVenuesFromJson(e.Result) ;
}

 

Conclusion

Comme vous l’avez constaté, il est relativement simple d’utiliser l’API Foursquare. Celle-ci permet en plus de très nombreuses choses, non explorées ici.

La géolocalisation étant un des enjeux majeurs des technologies d’aujourd’hui et de demain, il est important de maîtriser les outils qui permettent son exploitation en vue d’améliorer l’expérience utilisateur.

Share Button

Windows phone 7 VS Android : match retour

Introduction

Il y a un peu moins d’un an, j’écrivais un article nommé Windows phone 7 VS Android : point de vue d’un développeur, où j’exposais mon point de vue sur les deux plateformes, et leurs intérêts pour les développeurs d’applications.

Mais un an après, les choses ont changées, en partie. Il est donc temps de rejouer le match !

 

One Year After

Que ce soir du côté de Windows Phone 7 ou d’Android, nous avons vu, en l’espace d’un an, paraitre plusieurs événements majeurs.

Côté Microsoft, la mise à jour Mango a été déployée. Elle apporte un lot conséquent de nouveautés, que ce soit pour l’utilisateur ou les développeurs. Je vous conseille cet article de Pierre Cauchois pour en savoir plus. Nokia a également rejoint la bataille il y  a quelques mois, et a réellement aidé à diffuser Windows Phone auprès du grand public, avec sa gamme Lumia.

Côté Android, malgré une version 3.0 relativement intéressante, le système n’a pas convaincu, d’autant que la version 4.0 était très attendue. En effet, celle-ci avait pour but de réunir enfin smartphones et tablettes sur la plateforme. Le miracle est arrivé en Octobre dernier. Même si sa présence n’est pas encore grande, cette version 4.0 porte de nombreux espoirs ! D’ailleurs, il suffit de voir la vidéo suivante pour s’en convaincre :

 

Les outils

Un an après, les outils ont-ils beaucoup évolué ? Oui et non.

Côté Android, on retrouve toujours Eclipse et Netbeans. Néanmoins, l’IDE intelliJ de chez Jetbrains s’est joint à la bataille. Ce dernier est très apprécié de bon nombre de développeurs Java, mais dispose néanmoins d’une intégration à Android moins poussée que ce qu’on peut avoir sur Eclipse (oubliez les interfaces graphiques pour modifier vos ressources par exemple).

Néanmoins, du côté d’Eclipse justement, de nombreuses améliorations ont eu lieu. Ainsi, l’éditeur d’interfaces graphiques est enfin utilisable et pratique, et nous propose, via une nouveauté nommée Android Lint, de petites astuces de performance pour nos interfaces. Peu intrusif et très pratique !

Malgré tout, il reste toujours quelques bugs parfois (le xml qui disparait de l’écran par exemple), et le système DDMS n’a que peu évolué (même s’il était déjà très complet). Côté émulateur, c’est beaucoup plus rapide qu’avant, mais ça reste un peu douloureux, particulièrement pour émuler une tablette.

Du côté de Visual Studio, pas de changements majeurs, mais des nouveautés bienvenues. On note par exemple un outil complémentaire à l’émulateur, et qui permet de simuler une localisation pour le GPS, de jouer avec l’accéléromètre, et de prendre des screenshots facilement. Finie la galère des captures d’écran pour le marketplace !

D’ailleurs, concernant ce dernier, un nouvel outil nommé Marketplace test kitpermet de lancer quelques tests de conformité avant de publier votre application. Au niveau des vérifications, on y trouve la gestion du bouton back, le temps de démarrage, la gestion de la mémoire etc. Il y a également une liste de tests à faire manuellement, pour que vous puissiez être vraiment sûr que votre application est parfaitement conforme.  Enfin, vous pouvez maintenant changer le skin de votre émulateur. Vous en rêviez n’est-ce pas ?

Nokia Lumia 800

Au final, les deux partis ont apporté des améliorations appréciables, mais Visual Studio n’en reste pas moins bien plus pratique que son concurrent open-source !

 

Parlons design

Commençons par l’essentiel : le design d’interfaces n’a pas changé de façon de faire en un an. Android utilise toujours du xml pour définir les contrôles visuels, et WP7 a conservé le célèbre XAML (qui sera également utilisé dans Windows 8).

Néanmoins, au niveau des outils, des améliorations ont fait leur apparition. Du côté WP7, on trouve plus de maturités et de plus en plus de toolkits sont disponibles, sans parler de celui de base qui est de plus en plus fourni. On disposait déjà d’outils très performants comme Blend, de ce côté-là, difficile de faire mieux.

ICc Cream SandwichCôté Android en tout cas, on a vu arriver une véritable révolution : un éditeur visuel ENFIN performant. Un positionnement intuitif, des menus contextuels très bien pensés pour modifier les propriétés, une possibilité très simple de créer des interfaces spécifiques pour les tablettes ou différentes versions d’Android, sans compter Android Lint dont j’ai parlé avant. Sans attendre un niveau de qualité comme celui de Blend, On a enfin un outil utilisable !

Mais il manquait un élément important à la plateforme auparavant : des guidelines pour le design. Et voilà que le 12 Janvier dernier, Google a ouvert un site justement dédié au design pour Ice Cream Sandwich. Bon nombre de règles restent néanmoins applicables aux précédentes versions. Le site est très bien fait et comble un véritable manque pour la plateforme. Allez y faire un tour !

http://developer.android.com/design/index.html

Malgré tout, Android est en train de payer cher sa fragmentation. Bon nombre de propriétés d’animation et de rendu graphique sont apparus avec Android 3.0 (rotation ou alpha par exemple), et ne sont donc pas compatibles sur Android 2.x, vous devrez donc vous arranger autrement. Sur Windows Phone, on dispose depuis le début de nombreuses propriétés d’animation (même si on ne dispose pas des effets de Silverlight comme les ombres ou le blur).

A mon sens, même si Android a pas mal rattrapé son retard, WP7 conserve une bonne longueur d’avance en matière de création d’UI.

 

Les fonctionnalités

Ici, toujours aussi difficile de faire des comparaisons. En effet, Android nous propose l’accès à à peu près tout le système. Cela nous donne un grand contrôle, mais donne parfois une impression de devoir tout recoder, et ça peut vite devenir long.

Un bon exemple est celui du stockage d’informations. Pour nos applications, on peut passer par un système de préférences, le système de fichier, ou une base de données SQLLite. Certes, on a le choix, mais quid de la facilité d’utilisation ? Montrez la base de données à des débutants, vous allez vite voir le regard qu’ils vont vous jeter.

A contrario, sur Windows Phone 7, on dispose effectivement d’une base de données embarquée, mais nous pouvons tout à fait s’en passer grâce à l’isolated storage, qui est d’utilisation très simple.

De plus, avec l’arrivée de Mango, de très nombreuses fonctionnalités supplémentaires sont apparues. On peut citer les sockets, les tâches de fond, les alarmes et reminders, l’accès aux calendriers et aux contacts, une API pour la caméra… En somme, une liste impressionnante de possibilités qui sont apparues, et qui sont simples d’accès. Ce n’est pas encore Android, certes, mais on s’en approche. Vous voulez une preuve qu’il reste du chemin à faire ? Pas d’accès au Bluetooth sur Windows Phone. Dommage non ?

Au final, même si les fonctionnalités sont parfois difficiles d’accès sur Android, elles restent plus nombreuses (avec les problèmes de sécurité inhérents).

 

Ecosystème

Avec plus de 10 milliards d’applications téléchargées, et 700 000 Android activés par jour, difficile de faire concurrence avec Windows Phone, qui, même s’il dispose d’une forte progression, et à vraiment commencé à se Android sur tabletterépandre avec l’arrivée de Nokia sur le marché, il reste encore du chemin à parcourir. De plus, Android est présent sur les tablettes, ce qui n’est pas le cas de son concurrent (même si une fois Windows 8 sorti, il est assez facile de porter ses applications WP7).

 

Conclusion

En un an, de grosses évolutions ont eu lieu dans les deux camps. Windows Phone 7 reste, à mon sens, plus pratique et agréable pour les développeurs. Néanmoins,  Android propose plus de fonctionnalités différentes, et cible surtout bien plus d’utilisateurs (sans compter les tablettes). De plus, il reste encore certaines API manquantes qui interdisent d’office à WP7 d’avoir certains types d’application (Bluetooth par exemple).

Néanmoins, sachez qu’il est possible de porter une partie de son code depuis WP7 vers Android, et inversement (merci la ressemblance entre C# et Java), du moins du côté de la logique. Vous pouvez toujours développer sur ces deux plateformes en même temps non ?

Et quid des technologies web ? Développez pour un webbrowser et l’embarquer dans une application avec une librairie comme PhoneGap ? Hum… Vous voulez parler d’une application qui ne respecterait pas les guidelines de chaque plateforme et offrirait donc une expérience dégradée ? Non, vous pouvez oublier.

 

Share Button

Utiliser le Reverse-Geocoding sur Windows Phone 7

Introduction

Dans un contexte où les applications mobiles utilisent de plus en plus la localisation, il peut être très utile de récupérer l’adresse de l’utilisateur à partir de sa position géographique. On peut ainsi le guider, ou lui proposer des services se trouvant à proximité. Cet article a donc pour but de vous montrer comment utiliser cette méthode dite « Reverse-Geocoding ».

Note : Nous n’allons ici récupérer qu’une adresse, et non le nom d’un lieu à proximité. Ce processus-là s’appelle la recherche de POI (points of interest), et dépend d’une autre API. Si vous souhaitez l’utiliser, la documentation se trouve ici : http://msdn.microsoft.com/en-us/library/cc980861.aspx

 

Ajouter le service Bing

Avant de faire du reverse-geocoding, il faut ajouter une référence au service Bing qui propose cette fonctionnalité. Pour ce faire, il suffit de faire un clic droit sur votre solution, puis « Add a service reference »

AddServiceReference

L’url du service à rentrer est : http://dev.virtualearth.net/webservices/v1/geocodeservice/geocodeservice.svc

Cela devrait vous ajouter toutes les classes nécessaires au reverse-geocoding.

 

Appeler le service

Une fois le service ajouté, il va falloir l’ajouter. Pour ce faire, il vous faudra tout d’abord obtenir une clé API Bing Maps, disponible gratuitement sur https://www.bingmapsportal.com/

On va ensuite créer un objet de type ReverserGeocodeRequest, en lui soumettant notre clé d’API et la localisation dont l’on souhaite l’adresse.

ReverseGeocodeRequest reverseGeocodeRequest = new ReverseGeocodeRequest();
reverseGeocodeRequest.Credentials = new Credentials();
reverseGeocodeRequest.Credentials.ApplicationId = "APIKEY";
reverseGeocodeRequest.Location = new Location() { Longitude = lon, Latitude = lat };

Ensuite, il nous faut créer un objet de type GeocodeServiceClient, de préciser le type de binding pour le service, et enfin de lancer, de manière asynchrone, l’appel au service

GeocodeServiceClient geocodeService =
new GeocodeServiceClient("BasicHttpBinding_IGeocodeService");
geocodeService.ReverseGeocodeCompleted += new EventHandler<ReverseGeocodeCompletedEventArgs>(ReverseGeocodeCompleted);
geocodeService.ReverseGeocodeAsync(reverseGeocodeRequest);

Gérer la réponse

Pour gérer la réponse du service, nous allons devoir récupérer les résultats depuis l’objet ReverseGeocodeCompletedEventArgs, qui contient un attribut Result, qui lui-même contient une ObservableCollection de GeocodeResult.

Cet objet GeocodeResult contient nombre d’informations intéressantes. L’adresse bien entendu, mais également des localisations plus précises de l’adresse, les coordonnées à spécifier pour avoir la meilleure vue possible de l’endroit, ainsi qu’un objet Adress qui contient les différents éléments du lieu. Si vous souhaitez simplement utiliser l’adresse au format complet, pour un simple affichage, un attribut nommé DisplayName existe dans ce but.

 

void ReverseGeocodeCompleted(object sender, ReverseGeocodeCompletedEventArgs e)
{
    MessageBox.Show(e.Result.Results[0].DisplayName);
}

Conclusion

Le reverse-geocoding est une technique simple à utiliser, mais qui pourtant peut apporter un réel intérêt à votre application et ouvre la porte à de nombreux scénarios autour de la localisation.

Share Button

Faire une capture d’écran in-app et la sauvegarder sur WP7

Introduction

Il arrive parfois que l’on souhaite effectuer une capture d’une partie ou de tout l’écran d’une application Windows Phone 7. Cela peut être pour créer une sorte d’album photos dans un jeu, ou encore proposer un historique visuel pour vos utilisateurs.

Dans le cadre de la création d’un jeu nommé GeoWarfare, il me fallait prendre une capture d’écran d’un contrôle Bing Maps afin de proposer à l’utilisateur de savoir quelle était sa dernière localisation. Le but va donc être de prendre une capture d’un contrôle, la sauvegarder en Isolated Storage (après l’avoir convertie en Jpg), et la récupérer plus tard pour affichage.

 

Prendre une capture d’écran

Prendre une capture d’écran se révèle être très simple. D’ailleurs, j’en avais déjà parlé dans un précédent article. Il nous faut utiliser la classe WriteableBitmap. Son constructeur propose plusieurs surcharges. L’une d’entre elles nous intéresse particulièrement. Elle prend en paramètre un contrôle à capturer, et un objet Transform.

WriteableBitmap wb = new WriteableBitmap(mapBing, new ScaleTransform());

 

Lorsque WriteableBitmap a été présenté, dans Silverlight 3, il était dit que la transformation obligatoire était un bug. A priori, ce n’est pas le cas, mais la transformation précisée ici ne sert à rien, malgré son caractère obligatoire.

 

Convertir en Jpg

Une fois notre WriteableBitmap obtenu, il nous faut le transformer en image. En Silverlight classique, il nous fallait passer par une librairie tierce. Mais sur Windows Phone, il existe une extension qui permet justement de transformer un WriteableBitmap en image Jpg, en passant en paramètre un FileStream de l’isolatedStorage, ainsi qu’une éventuelle orientation et la qualité de l’image. Le code final donne cela :

using (IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication())
 {
       WriteableBitmap wb = new WriteableBitmap(mapBing, new ScaleTransform());

       string fileName = "monImage.jpg";
       if (isoStore.FileExists(fileName))
            isoStore.DeleteFile(fileName);
       IsolatedStorageFileStream fileStream = isoStore.CreateFile(fileName);

       System.Windows.Media.Imaging.Extensions.SaveJpeg(wb, fileStream, wb.PixelWidth, wb.PixelHeight, 0, 85);

       fileStream.Close();
}

 

Afficher l’image

Pour afficher l’image, rien de plus simple. Il suffit aller chercher le fichier dans l’isolatedStorage, de l’ouvrir, et de mettre le contenu en source d’un objet BitmapImage. Ce même objet peut ensuite être mis en source d’un contrôle Image classique !

BitmapImage bee = new BitmapImage();
string pathImage = "monImage.jpg";

using (IsolatedStorageFile isoStorage = IsolatedStorageFile.GetUserStoreForApplication())
{
      if (isoStorage.FileExists(pathImage))
      {
             using (IsolatedStorageFileStream fileStream = isoStorage.OpenFile(pathImage, FileMode.Open, FileAccess.Read))
             {
                  bee.SetSource(fileStream);
                  monImage.Source = bee;
             }
      }
}

 

Exemple par l’image

Voici le résultat sur l’application GeoWarfare pour Windows Phone :

 

Dernier secteur visité dans GeoWarfare

Dernier secteur visité dans GeoWarfare

Conclusion

Cette technique relativement simple peut vraiment apporter un énorme plus à votre application. Que ce soit en terme d’ergonomie, d’optimisation ou juste d’expérience utilisateur, n’hésitez pas à vous en servir !

 

Share Button