[WP7] Le SDK Windows Phone 7.8 est disponible

Le 24 janvier 2013 à 15:17

Comme vous le savez certainement, le déploiement de la mise à jour 7.8 sur les terminaux Windows Phone 7 serait imminent. Microsoft a donc publié la mise à jour du SDK pour Windows Phone 7.8 il y a deux jours.

windows-phone-7-8-lumia

Quelles sont les nouveautés  pour les développeurs ?

L’ajout de deux émulations relatifs à Windows Phone 7.8, l’un pour les terminaux avec 512MO et l’autre pour 256MO. Il n’y a pas de nouveautés dans les API. Microsoft précise surtout que les émulateurs ont été ajoutés surtout pour vérifier le bon fonctionnement des applications en version 7.5 (voir le comportement des Live Tiles par exemple).

Il est bon de savoir également de rappeler que toutes les applications développées avec les versions antérieures à WP8 seront compatibles avec celui-ci. Donc pour le moment, et c’est mon avis, il est préférable d’assurer une compatibilité de ses applications avec les versions antérieures à WP8, pour pouvoir toucher un maximum de terminaux.
Pour télécharger le nouveau SDK, ça se passe par ici.

A bientôt !

[WP7] Utilisation du mode Trial

Le 10 août 2011 à 11:12

Le mode trial permet aux utilisateurs de tester votre application avant de l’acheter. C’est à dire qu’on va pouvoir brider des fonctionnalités afin d’attirer l’utilisateur vers la version payante. Sa mise en place est très simple, il suffit de vérifier si le mode trial est actif sur l’application en cours, pour cela il faut utiliser la classe LicenseInformation qui contient la propriété IsTrial (pour XNA, il faut regarder du côté de Guide.IsTrialMode) :

public static Boolean IsTrial
{
    get 
    {
        LicenseInformation license = new LicenseInformation();
        return license.IsTrial();
    }
}

 

Pour que ce soit pratique en développement, on peut faire de la compilation conditionnelle en renvoyant la valeur “true” si on est en mode debug :

public static Boolean IsTrial
{
    get 
    {
        #if DEBUG
            return true;
        #endif

        LicenseInformation license = new LicenseInformation();
        return license.IsTrial();
    }
}

 

Ensuite, il devient très simple d’effectuer des actions selon la lience en cours :

if(IsTrial)
{
    // afficher message si mode trial, 
    // par exemple l'ajout d'infos limité à 5 items
}

// action si pas trial
// ...

 

A bientôt !

[WP7] Localisez le titre de votre application

Le 9 août 2011 à 15:45

Nous avons vu récemment la globalisation de son application mais vous aurez surement remarqué qu’il n’était pas possible de localiser le titre de l’application. C’est à dire le Tile de l’application comme illustré ci-dessous :

image

Pour faire cela, il va falloir créer une dll AppResLib qui est en fait une dll ressource Win32 classique. La procédure n’est pas compliqué mais ne ressemble pas à ce qu’on a l’habitude de faire sur WP7 ;).

Donc, il faut ajouter un projet Win32 à notre solution :

image

 

Dans la fenêtre de l’assistant, choisir comme type d’application “dll” et comme option supplémentaire “projet vide” :

image

 

Ensuite, une fois le projet crée, il faut se rendre dans ses propriétés (clique droit, propriétés) puis se rendre dans “Editeur de liens” > “Avancé” et choisir en “Aucun point d’entrée” la valeur “oui (/NOENTRY)”.

image

 

Maintenant il va falloir ajouter un langage “neutre” en ressource à la DLL (par exemple le français, celle qui sera affichée par défaut si la ressource de langue n’est pas disponible), pour cela, il faut ajouter une ressource et dans celle ci une String Table contenant deux valeurs :

 

image

 

image

 

image

Comme indiqué dans l’image ci-dessus, il y aura deux valeurs “AppTitle” qui sera le nom de l’application dans la liste des applications et “AppTileString” qui sera le nom affiché dans la mosaïque des applications sur l’écran d’accueil.

 

Une fois le langage neutre créé, on va compilé la ressource et l’incorporé dans notre projet WP7. Il suffit de localiser la DLL générée et la copier dans la racine du projet WP7 :

image

 

Maintenant on va ajouter une langue supplémentaire, c’est à dire l’anglais, il suffit d’éditer la ressource de la DLL et d’y remplacer les valeurs par celles traduites en anglais :

image

 

Ensuite on va recompiler la dll et la copie la racine de notre projet WP7 mais en la renommant AppResLib.dll.0409.mui (US)

Voici les diférents codes selon les langues :

English (United States) (0x409) (/l 0x0409) / AppResLib.dll.0409.mui

English (United Kingdom) (0x809) (/l 0x0809) / AppResLib.dll.0809.mui

French (France) (0x40c) (/l 0x040c) / AppResLib.dll.040c.mui

German (Germany) (0x407) (/l 0x0407) / AppResLib.dll.0407.mui

Italian (Italy) (0x410) (/l 0x0410) / AppResLib.dll.0410.mui

Spanish (Spain) (0xc0a) (/l 0x0c0a) / AppResLib.dll.0c0a.mui

 

Ce qui donnera à notre racine :

image

 

Voila, nos ressources sont prêtes. Il faut à présent indiquer au téléphone qu’il existe ces ressources.

Tout d’abord on va ajouter ces fichiers au projet :

image

Puis dans les propriétés de ces fichiers, on va définir en action de génération la valeur “contenu” (donc ces Dll seront copiées dans le XAP) :

image

 

Maintenant, il faut modifier le fichier WMAppManifest.xml dans le projet (clique droit sur Propriétés, le fichier est là) :

image

Il faut ensuite recherche dans App le Title de votre application et remplacer par “@AppResLib.dll,-100”, puis dans PrimaryToken, recherche le Title et remplacer par “@AppResLib.dll,-200”

Voici le fichier à quoi il devrait ressembler :

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

<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2009/deployment" 
AppPlatformVersion="7.0">
  <App xmlns="" ProductID="{f12ae759-54b6-49fe-84b9-94a60ac066c2}" 
       Title="@AppResLib.dll,-100" 
       RuntimeType="Silverlight" 
       Version="1.0.0.0" 
       Genre="apps.normal" 
       Author="SampleApp author"
       Description="Sample description"
       Publisher="SampleApp">
    <IconPath IsRelative="true" IsResource="false">ApplicationIcon.jpg</IconPath>
    <Capabilities>
      <Capability Name="ID_CAP_GAMERSERVICES"/>
      <Capability Name="ID_CAP_IDENTITY_DEVICE"/>
      <Capability Name="ID_CAP_IDENTITY_USER"/>
      <Capability Name="ID_CAP_LOCATION"/>
      <Capability Name="ID_CAP_MEDIALIB"/>
      <Capability Name="ID_CAP_MICROPHONE"/>
      <Capability Name="ID_CAP_NETWORKING"/>
      <Capability Name="ID_CAP_PHONEDIALER"/>
      <Capability Name="ID_CAP_PUSH_NOTIFICATION"/>
      <Capability Name="ID_CAP_SENSORS"/>
      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT"/>
    </Capabilities>
    <Tasks>
      <DefaultTask  Name ="_default" NavigationPage="MainPage.xaml"/>
    </Tasks>
    <Tokens>
      <PrimaryToken TokenID="SampleAppToken" TaskName="_default">
        <TemplateType5>
          <BackgroundImageURI IsRelative="true" 
                                        IsResource="false">Background.jpg</BackgroundImageURI>
          <Count>0</Count>
          <Title>@AppResLib.dll,-200</Title>
        </TemplateType5>
      </PrimaryToken>
    </Tokens>
  </App>
</Deployment>

 

Voila c’est terminé, un peu long mais ce n’est pas compliqué :)

A bientôt !

[WP7] Mango : créer une application de streaming Radio avec AudioPlayerAgent

Le 8 août 2011 à 20:42

Actuellement sous WP7 Nodo, lorsque vous utilisez une application autre que Zune pour la lecture audio (application radio, Deezer, application GPS… etc) l’audio s’arrête à partir du moment où vous switchez sur une autre application : elle ne continue  donc pas de jouer en background.

Avec Mango, il est désormais possible de le faire. Pour cela, il faut utiliser un Agent disponible sur le dernier SDK 7.1 : AudioPlayerAgent. Cet agent va nous permettre de contrôler ce qui va être jouer et d’interagir selon ce que l’utilisateur va faire (boutons lecture/pause, morceau précédent/suivant) et ce qu’on va afficher (titre, nom de l’album, image de l’album… etc).

Ici, je vais créer une mini application (simple) de streaming d’une radio. Bien entendu il pourrait être complexifié pour y ajouter le contrôle de plusieurs flux de radio. Mais en voyant l’exemple, vous comprendrez que c’est très facilement adaptable :).

Pour commencer, on va créer une application WP7.1, puis on va y ajouter un projet Windows Phone Audio Playback Agent :

image

Le template va nous créer une classe qu’on va compléter. Cette classe dérive de AudioPlayerAgent. La classe surcharge les méthodes OnPlayStateChanged (à chaque fois qu’on change l’état du track), OnUserAction (quand l’utilisateur appuie sur un bouton) et OnError (quand une exception est déclenché).

Il faut savoir qu’une source de flux est définie par la classe AudioTrack.
On va déjà définir un AudioTrack pointant vers notre flux radio (ici France Info):

private static readonly AudioTrack Track =
    new AudioTrack(
     new Uri(@"http://mp3.live.tv-radio.com/franceinfo/all/franceinfo.mp3", UriKind.Absolute),
     "France Info live", "France Info", "France Info podcast", null, null, 
     EnabledPlayerControls.Pause);

 

EnabledPlayerControls va nous permettre de choisir les actions qui seront possibles pour l’utilisateur, ici j’ai désactivé la possible de faire suivant et précédent.
Maintenant on va écrire le code de la méthode surchagée OnUserAction. Cela nous permettra selon l’action demandé de mettre en pause le flux ou de le lire, selon ce que l’utilisateur a souhaité faire :

protected override void OnUserAction(BackgroundAudioPlayer player,
AudioTrack track, UserAction action, object param)
{
    switch (action)
    {
        case UserAction.Play:
            if (PlayState.Paused == player.PlayerState)
            {
                player.Play();
            }
            else
            {
                player.Track = Track;
            }
            break;

        case UserAction.Pause:
            player.Pause();
            break;
    }
    
    NotifyComplete();
}

 

Maintenant on va s’occupé de la méthode OnPlayStateChanged, qui va nous permettre d’éffectuer des actions selon le Playstate :

switch (playState)
{
    case PlayState.TrackReady:
        player.Play();
        break;
}

NotifyComplete();

 

Et voila, c’est quasiment terminé pour notre agent !

Du côté du projet WP7, pour pouvoir manipuler l’agent, il suffit d’utiliser la classe BackgroundAudioPlayer :

Pour lire :

BackgroundAudioPlayer.Instance.Play();

 

Pour supprimer la lecture :

BackgroundAudioPlayer.Instance.Close();

 

P1040263-(1)

 

Lorsque vous serez sur le home screen, vous aurez l’information de la lecture en cours, et lorsque vous serez sur l’accueil et que vous utilisez les boutons de volume, vous aurez également l’information du morceau en cours. 

Pour télécharger les sources, c’est par ici.
A bientôt !

[WP7] Globalisez vos applications Windows Phone 7

Le 8 août 2011 à 09:34

Afin de toucher un beaucoup plus de monde sur Windows Phone 7, traduire vos applications en plusieurs langues est un véritable plus. Un peu à la manière de WPF, il existe plusieurs méthodes pour globaliser son application (fichiers de ressources, fichiers dictionnaires XAML, frameworks… etc).

Ici on va utiliser la méthode que Microsoft recommande sur MSDN. C’est-à-dire l’utilisation des fichiers de ressources (un fichier par langue).

Tout d’abord, on va définir une langue par défaut dans notre application, en tout bon français que je suis, je vais lui dire que mon projet est français :) :

image1

Maintenant, on va lui ajouter les fichiers qui vont contenir les ressources de notre application tout d’abord pour commencer (qui seront les valeurs traduites que l’on va lui définir), ajoutez un fichier de ressource dans votre projet :

image2

Comme on a défini la langue par défaut de notre application sur « Français », le fichier Labels.resx contiendra les valeurs pour le français. Pour ajouter un fichier pour l’anglais par exemple, il faut de nouveau ajouter un fichier de ressource sur la syntaxe suivante : [Nomdufichier].[Culture].resx.

Pour la liste des cultures disponibles, allez faire un tour sur msdn.

Pour notre exemple, on va ajouter le fichier de ressource anglais :

image3

Pour valider les cultures supportées par notre application, il faut ouvrir le fichier csproj de l’application et rechercher la balise <SupportedCultures>, et lui indiquer la liste des culture que l’on supporte (à séparer par des ; entre chaque culture), ici :

<SupportedCultures>fr-FR;en-US</SupportedCultures>

On va à présent ajouter dans les fichiers de ressources les valeurs pour la traduction.
Tout simplement, on va ajouter cette valeur :

image4

Et faire de même pour le fichier anglais :

image5

On en profite pour passer le modificateur d’accès en public

Petite remarque, comme vous le pouvez le remarquer, si on ajoute une valeur dans le fichier principal « Labels.resx », rien n’est répliqué sur le fichier de ressources anglais. Alors quand on a un projet de quelques dizaines de lignes, ça peut passer encore, mais quand le fichier est trop important, ça devient vite une usine à gaz à gérer.

Pour cela, je vous conseille d’utiliser l’excellent logiciel Zeta Resource Editor. Il est gratuit, écrit en .NET et open source. Il va vous permettre de calquer facilement vos ressources sans vous prendre la tête J.

Maintenant, pour pouvoir facilement binder vos ressources à votre interface, ou à votre code, on va créer une classe statique qui va nous permettre de le faire facilement, ici je la nomme LocalizedStrings :

class LocalizedStrings
{
    private static Resources.Labels resource = new Resources.Labels();

    public Resources.Labels Localizedresources { get { return resource; } }

    public LocalizedStrings()
    {
    }
}

Ensuite, déclarer la classe dans un dictionnaire de ressource, pour qu’on puisse l’appeler directement via XAML (ici directement dans App.xaml) :

<Application.Resources>
    <WP7Lang:LocalizedStrings xmlns:WP7Lang="clr-namespace:WP7Lang"
                                        x:Key="LocalizedStrings" />
</Application.Resources>

Voilà, notre application est disponible en plusieurs langues ! Il suffit de binder les valeurs dans notre interface ou dans le code maintenant :) :


Côté XAML :

<TextBlock Name="txtHello" VerticalAlignment="Center" HorizontalAlignment="Center" 
  Text="{Binding Path=Localizedresources.Hello, Source={StaticResource LocalizedLabels}}" />

Côté code :

CultureInfo newCulture = new CultureInfo("fr-FR");

Thread.CurrentThread.CurrentCulture = newCulture;
Thread.CurrentThread.CurrentUICulture = newCulture;

 

Par contre, vous l’avez surement remarqué mais lorsque vous changez de Culture, les valeurs ne sont pas automatiquement changé dans votre UI (juste dans votre code si vous appelez les ressources vous-même).

C’est assez logique car en effet, on ne notifie pas l’interface des changements qui sont intervenus, pour cela il faut passer par INotifyPropertyChanged, donc nous allons modifier LocalizedStrings comme ceci :

public class LocalizedStrings : INotifyPropertyChanged
{
    private static readonly Resources.Labels Resource = new Resources.Labels();
    public Resources.Labels Localizedresources { get { return Resource; } }

    public LocalizedStrings()
    {
        
    }

    public void ChangeLanguage(String codeLang)
    {
        CultureInfo newCulture = new CultureInfo(codeLang);
        Resources.Labels.Culture = newCulture;

        Thread.CurrentThread.CurrentCulture = newCulture;
        Thread.CurrentThread.CurrentUICulture = newCulture;

        OnPropertyChanged("Localizedresources");
    }


    #region INotifyPropertyChanged Members

    PropertyChangedEventHandler propertyChanged;
    public virtual event PropertyChangedEventHandler PropertyChanged
    {
        add { propertyChanged += value; }
        remove { propertyChanged -= value; }
    }

    public virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = this.propertyChanged;
        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    #endregion
}


Maintenant dans notre code, pour récupérer l’instance de LocalizedStrings définie dans App.xaml :

private LocalizedStrings _resources = 
        Application.Current.Resources["LocalizedLabels"] 
                                            as LocalizedStrings;

 

Pour changer de langue :

_resources.ChangeLanguage("fr-FR");

 

Pour utiliser les ressources directement dans le code :

MessageBox.Show(Labels.ResourceManager.GetString("Hello"));


Voilà maintenant, lorsqu’on change de Culture, tout est immédiatement bindé dans notre interface.

Vous pouvez télécharger la source exemple ici.

A bientôt !

A propos de l'auteur

Mathieu Perrein est Software Solutions Architect, Microsoft Student Partner de 2010 à 2012.

 

MSP

 

MSP

MSP

 MSPD

MCT

 

Facebook

 

Ce blog est strictement personnel et les opinions exprimées ici n'engagent donc que moi, et pas mon employeur.

Tags

Vous avez désactivé JavaScript ou bien vous possédez une ancienne version d'Adobe Flash Player. Téléchargez la dernière version de Flash Player.