Browsed by
Month: May 2011

Tiletris : un tetris directement sur la home de windows phone 7

Tiletris : un tetris directement sur la home de windows phone 7

Le SDK de mango vient à peine de sortir que j’avais envie de faire un coding4fun afin de découvrir les nouvelles fonctionnalités de la mise à jour 7.1

De plus le challenge est encore plus intéressant étant donné que la documentation msdn n’est pas encore en ligne.

Mon but donc étant d’écrire un tetris, utilisant les live tiles de windows phone 7 pour l’affichage et utilisant au choix, soit des live tiles spécifiques pour contrôler les pièces, soit les contrôles Zune natifs du téléphone (notamment les touches chanson suivante/précédente). Le défi est donc de pouvoir jouer sans lancer d’application !

Pour réaliser la première version, il m’a fait fallu 3h, décomposé en 1h pour décrire et tester les nouvelles fonctionnalités et 2h pour coder le système de gameplay et l’affichage.

Cette première version utilise donc : les multi live tiles ainsi qu’un live agent pour le gameplay afin de rafraichir les tiles et pour gérer les interactions entre briques. Le rafraîchissement entre deux live tiles est de 3 secondes, il n’est pas possible de descendre en dessous, le système ignorant alors certaine mise à jour.


 

J’ai créé une deuxième version qui cette fois utilise les contrôles Zune pour bouger/tourner la pièce, pour cela, j’utilise un BackgroundAudioPlayer afin de récupérer les évènements sur les touches et d’accessoirement jouer une musique, l’idée étant vraiment de détourner les nouvelles fonctionnalités. En plus de cela, une live tile affiche le score de l’utilisateur ainsi que la pièce suivante.

Je publierais un article sur un aspect plus technique dans les jours à venir.

Conférence : Nokia et sa stratégie

Conférence : Nokia et sa stratégie

La nouvelle stratégie Nokia : Conséquences et opportunités pour l’écosystème mobile
Aujourd’hui avait lieu la conférence “La nouvelle stratégie Nokia : Conséquences et opportunités pour l’écosystème mobile” à la cantine numérique de Rennes.

Présenté par Bertrand Dupuis, Directeur Marketing des Services de Nokia, la conférence présentait la nouvelle stratégie de Nokia suite à son partenariat avec Microsoft annoncé le 11 février. Etait aussi présent Julien Amouroux, Developer Marketing Manager de Nokia.

Nokia a abordé plusieurs sujets : Symbian, Qt et Windows Phone 7. Pour ce résumé, je vais me concentrer sur le côté Windows Phone 7.

La stratégie

Nokia développe et développera “des mobiles extraordinaires”.

L’idée est vraiment de redevenir leader sur la téléphonie mobile et notamment sur les smartphones. Pour ceci, Nokia se basera sur 3 piliers :

– les smartphones : le partenariat avec microsoft

– comment on peut aller chercher le prochain milliard d’utilisateurs connectés à l’internet mobile (inde, chine notamment)

– comment participer à la prochaine rupture, comme apple avait enclenché la rupture smartphone il y a quelques années.

Le tout en se différenciant, le but étant de s’éloigner du smartphone noir, clone de iphone (ndlr : samsung galaxy S) au niveau design et R&D

Pourquoi Nokia s’est rapproché de Microsoft

Nokia est conscient que Symbian est un OS vieillissant et qu’il n’a pas forcément répondu aux attentes des utilisateurs niveau expérience utilisateur. De plus, Nokia veut se reconcentrer dans son métier principal : le hardware, leurs plus-values est la dedans. Donc pour redevenir leader sur le marché des smartphones, il faut s’associer avec un fabricant d’OS qui a déjà tout un ecosystème en place. Aujourd’hui, il n’y en a que 3 majeurs : Apple, Google et Microsoft.

Apple n’est pas un candidat, la firme de cupertino ne distribuant pas son OS.

Google via android peut être une solution tout comme Microsoft via Windows Phone 7.

 

Pourquoi pas android ?

 

Nokia n’a pas choisi android pour plusieurs raisons :

– niveau business model, Nokia ne s’est pas reconnu dedans. Google offre son OS et ensuite récupère la monétisation via la publicité. Nokia ne veut pas prôner ce système, ils préfèrent intégrer l’opérateur téléphonique dans la chaine de valeur, et donc l’opérateur va revendre les mobiles et c’est lui qui à travers ses politiques de contenus et de revente de minutes qui va récupérer la valeur que l’on fait au delà de la vente des mobiles

– Nokia a racheté Navtek il y a quelques années, il aurait été très difficile pour nokia de jouer sur la différence avec google maps

– les négociations avec android ont été plus compliquées qu’avec microsoft.

Comment Nokia et Microsoft se complètent

Nokia s’est trouvé beaucoup de complémentarité avec Microsoft contrairement à android où ils se sont trouvé plus de concurrence.

 

Ce que Nokia apporte

Nokia peut apporter du hardware et à une grande maîtrise dans ce domaine.

Nokia dispose d’accords commerciaux avec les revendeurs téléphoniques que microsoft n’avait pas, Nokia étant présent dans plus de 150 pays. Il faut savoir que contrairement à la france, ou la vente de mobile est fait en majorité par les boutiques des opérateurs, ce n’est pas forcément le cas dans tous les pays ou les revendeurs (type phone house) sont le principal vecteur de vente et Nokia sait comment les adresser.

Les opérateurs téléphoniques partenaires et notamment les partenariats sur la refacturation des achats d’applications directement sur la facture de l’opérateur.

Navtek : il n’existe que deux sociétés disposant d’une cartographie planétaire, son concurrent étant le néerlandais Tele Atlas

Son expérience dans les stores avec notamment Ovi Store.

Ce que microsoft apporte

Son système d’exploitation Windows Phone 7, mais aussi potentiellement le prochain OS Microsoft sur tablette.

Microsoft apporte ad-center, sa régie publicité

La partie divertissement : XBox, Zune. Nokia n’a jamais réussi à attendre le domicile des utilisateurs.

L’écosystème de développeurs.

les réseau sociaux et le système de communication unifié (Lync, Windows Live) sur le mobile.

 

Pourquoi ne pas continuer avec symbian ou meego ?

Symbian est vieillissant, le temps presse et il fallait faire vite.

Pour meego, Nokia n’a pas réussi à assez fédérer de grands acteurs internet du marché pour aller plus vite. Toutefois, Nokia sortira un mobile en fin d’année sous Meego. Nokia ne se désintéresse pas pour autant de ce système, mais le met de côté, il pourrait servir de plateforme pour une prochaine rupture pour les futurs générations. Ils travaillent sur des concepts (mobiles projetés, 3D, etc…) meego pourrait être de la partie dans un modèle exploratoire.

Donc il était moins risqué de prendre un système existant et l’emmener vers un autre niveau en termes de volume, d’avoir un vrai partenariat ou nokia aura une valeur auprès de microsoft.

Le milliard suivant

Comment nokia va aller chercher les utilisateurs qui n’ont pas de smartphones et qui dans les années prochaines pourraient être intéressés. On parle notamment des pays immergeant (inde, chine), mais aussi de nos utilisateurs, on oublie facilement que les smartphones en france, ce n’est que 15-20% du marché français. Nokia souhaite donc vraiment aller chercher les nouveaux utilisateurs qui représentent 80% du marché français que de piquer les utilisateurs des concurrents.

Comment on va faire rentrer chez madame michu des mobiles connectés avec une réelle expérience mobile (html5) mais qui ont moins d’argents que des utilisateurs d’iphone. Cela passe donc par des mobiles à bas prix avec une expérience de navigation digne de ce nom et un OS pouvant accueillir des nouvelles applications. On ne parle pas spécifiquement ici de Windows Phone 7.

Les premiers Windows Phone

Les smartphones pour 2011 seront des symbian, Windows Phone 7 est pour début 2012 pour le volume. Toutefois un windows phone 7 sous mango sortira en 2011, toutefois  pas à de grand volumes, car le marché français est guidé par les opérateurs et pour vendre des mobiles en volume sur la fin d’année, il faut qu’ils arrivent en Juillet/Août dans les bacs, ce qui ne sera pas le cas.

Un des premiers smartphones pour 2012 sera un cran en dessous, moins cher, pour viser une autre cible.

Nokia travaille avec microsoft pour baisser les spécifications matérielles requises pour Windows Phone, afin de baisser les tarifs d’acquisition et donc d’adresser un public encore plus large.

Dans un premier temps, Symbian adressera le moyen de gamme alors que Windows Phone le haut de gamme. Symbian laissera sa place au fur et à mesure à Windows Phone jusqu’à 2014-2015 ou Symbian prendra une retraite bien mérité.

Nokia et son partenariat privilégié

Le premier Windows Phone qui sortira en 2011, aura un mango quasi brute, la valeur ajoutée sera sur le hardware et sur les applications embarquées.

Toutefois Nokia aura la main sur le système et compte bien pour 2012 modifier l’expérience utilisateur afin d’avoir vraiment une plus-value. Toutefois, il n’y aura pas de sectorisation, les applications windows phone tourneront sur tous les smartphones, compris Nokia, mais il sera possible d’utiliser des fonctionnalités supplémentaires sur les téléphones nokia. Les éditeurs pourront donc, s’il le souhaite, ajouter une expérience utilisateur spécifique aux nokia.

Toutefois, il n’a pas été abordé quelles seront ces modifications.

La partie qui va suivre n’est qu’une supposition de l’auteur !

A titre personnel, j’imagine ceci comme un gadget, une possibilité qui apportera une expérience en plus, mais pas du tout indispensable afin de ne pas sectoriser le marché. Par exemple, j’imagine :

– des hubs spécifiques nokia avec qui il sera possible d’interagir

– une possibilité d’interagir sur l’écran de verouillage

– un écran supplémentaire pour les notifications.

L’idée pour nokia est qu’il ne faut pas dénaturer l’OS, les applications devront tourner sur tous les téléphones, quel que soit la marque mais d’ajouter son petit plus.

Ovi Maps sur Windows Phone

Via le partenariat Microsoft-Nokia, Navtek fait partie du deal et donc sera intégrer dans windows phone quel que soit la marque du téléphone.

Le rachat par Microsoft

Le sujet a été abordé très rapidement et à évidemment pas été confirmé, au contraire.

Je vais plutôt donner ma vision de la chose.

Nokia est maintenant un partenaire très privilégie avec Microsoft, à tel point que les équipes des deux sociétés vont travailler ensemble (je pense notamment aux équipes de Bing Maps et Ovi Maps), de plus il ne faut pas oublier que le pdg actuel de nokia, Stephen Elop, est un ancien de microsoft. Nokia et microsoft travaille donc main dans la main, il n’y a donc aucun intérêt pour Microsoft de racheter Nokia, si ce n’est que de se fâcher avec ses autres partenaires mobiles que sont LG, samsung, HTC, Dell et nouvellement ZTE, fujisti et acer.

De plus, microsoft c’est avant tout du software, mis à part les périphériques et les consoles de jeu (mais difficile de faire différemment pour le coup), microsoft n’a jamais été vraiment intéressé par le hardware, même surface 2, c’est samsung.

 

Conclusion de l’auteur

J’ai beaucoup apprécié cette rencontre avec les acteurs de Nokia, ils semblent très motivé et ont de belles perspectives pour le système d’exploitation de microsoft. J’attends avec impatience les windows Phone Nokia (leurs appareils photo sont juste les meilleurs du marché), pas forcément le modèle de 2011, mais plutôt les modèles de 2012 quand Nokia se sera vraiment approprié la plateforme. Bertrand et Julien ont été vraiment très ouvert, simple et sympathique et  semble vraiment vouloir travailler avec la communauté (ce qui est réciproque lorsque l’on voit le nombre de développeur qui attente les téléphones de la firme finlandaise) et je pense que l’on travaillera ensemble prochainement.

Utilisation du background Audio

Utilisation du background Audio

Actuellement avec nodo, une application comme Deezer ne peut jouer une musique que lorsqu’elle visible, grâce à mango il est possible de demander au windows phone de continuer à jouer un morceau même si l’application est fermé.

Créez une librairie Windows Phone 7, celle-ci va contenir notre Agent, elle est totalement indépendante vis à vis de notre application. Quand on fermera l’application, seule cette librairie restera chargée.

Et ajoutez une référence à la dll dans votre application (indispensable).

Dans cette librairie, ajoutez une classe héritant de AudioPlayerAgent :

namespace TestAudioPlaybackAgent
{
    public class MyAudioPlayerAgent : AudioPlayerAgent
    {
    }
}

et surchargez les méthodes OnPlayStateChanged(BackgroundAudioPlayer player, AudioTrack track, PlayState playState) et void OnUserAction(BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param), la première correspond aux évènements de lecture (fin du morceau en cours,etc…) alors que la deuxième correspond aux évènements provenant de l’utilisateur : (lecture, pause, etc…)

      protected override void OnUserAction(BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param)
        {
            base.OnUserAction(player, track, action, param);

            // User actions can be initiated from the main application or from the UVC.
            switch (action)
            {
                case UserAction.Play:
                    Play(player);
                    break;

                case UserAction.Stop:
                    player.Stop();
                    break;
            }

            NotifyComplete();
        }

Il est indispensable d’appeler la méthode NotifyComplete() lorsque vous avez fini votre traitement afin que le téléphone puisse mettre de côté l’agent (jusqu’a prochain évènement)./

Enfin, il faut rajouter un BackgroundServiceAgent de type ‘AudioPlayerAgent’ au fichier WMAppManifest.xml de votre application dans le noeud “Tasks” :

   <extendedTask Name="BackgroundTask">
        <backgroundServiceAgent Specifier="AudioPlayerAgent" Name="TestAudioPlaybackAgent" Source="TestAudioPlaybackAgent" Type="TestAudioPlaybackAgent.MyAudioPlayerAgent" />
      </extendedTask>

Il nous reste plus qu’à implémenter la méthode Play() :

void Play(BackgroundAudioPlayer player)
{
player.PlayStateChanged += PlayStateChanged;
var track = new AudioTrack(
     new Uri("http://www.contoso.com/rebeccablack/itsfriday.mp3"),
     "it's friday",
     "Rebecca Black",
     "RebAlbum",
     new Uri("http://www.contoso.com/images/reb.jpg"));
 player.Play();
}

Il suffit donc de construire un objet AudioTrack et de lui passer en paramètres : l’uri vers le fichier audio (cela peut être un fichier local (dans l’isolated Storage, il faudra donc penser à copier les fichiers audio que vous souhaitez lire dans l’isolated storage de façon manuelle), le nom de la chanson, le nom de l’artiste, le nom de l’album et enfin la pochette de l’album.

Du côté client, il est possible de récupérer les états de la lecture (morceau suivant, rewinding, etc… grâce à la méthode “PlayStateChanged”.

void PlayStateChanged(object sender, EventArgs e)
{
   switch (BackgroundAudioPlayer.Instance.PlayerState)
   {
      case PlayState.XXX:
      ...
      break;
   }
}

Pour vérifier que le téléphone à bien pris en compte votre morceau, il suffit de taper la touche F9 ou F10 afin d’afficher les contrôles de Zune.

Pour résumé, le Background Audio est très simple d’utilisation et plutôt bien conçu (beaucoup plus simple que chez la concurrence…)

Utiliser les deep links avec les notifications push

Utiliser les deep links avec les notifications push

Une de mes applications (TVShow) utilise les notifications push afin d’indiquer à l’utilisateur qu’un épisode passe dans 10 minutes à la télé. Si l’utilisateur clique sur cette notification, il est renvoyé sur la page d’accueil de l’application et non sur la fiche correspondant à l’épisode. En effet, il n’est pas possible actuellement de référencer une page spécifique via les toasts. Mango ajoute cette possibilité, et voici comment l’utiliser :

Voila à quoi ressemblait les notifications jusqu’à maintenant :

<wp:Notification xmlns:wp="WPNotification">
  <wp:Toast>
    <wp:Text1>9 minutes </wp:Text1>
    <wp:Text2>épisode 6x10 de Desperate Housewives</wp:Text2>
  </wp:Toast>
</wp:Notification>

maintenant avec mango, on a un paramètre en plus wp:Param correspondant à la page vers laquelle l’utilisateur devra être redirigé.

<wp:Notification xmlns:wp="WPNotification">
  <wp:Toast>
    <wp:Text1>9 minutes </wp:Text1>
    <wp:Text2>épisode 6x10 de Desperate Housewives</wp:Text2>
    <wp:Param>/Episode.xaml?id=123</wp:Param>
  </wp:Toast>
</wp:Notification>

Il est évident que les deep link ajoute un niveau de complexité pour le chargement des données. Auparavant, on était sur de passer par la page MainPage, on pouvait donc afficher une UI spécifique indiquant le chargement des données. Il faudra donc faire attention lorsque l’on utilise les deep links à ce genre de problématique.

Utiliser les nouvelles tuiles via les notifications push

Utiliser les nouvelles tuiles via les notifications push

Si vous avez lu les deux articles précédents, vous savez qu’une tuile à maintenant deux facettes : un devant et un derrière.

On vient de voir comment les mettre à jour localement, nous allons donc maintenant voir comment les mettre à jour via les notifications push

Le formaliste du fichier xml pour le push à légèrement évolué afin de prendre en compte les nouvelles caractéristiques des tuiles :

On retrouve donc les propriétés que l’on avant auparavant :

  • Title : le titre qui sera affiché dans la partie inférieur gauche de la tuile
  • BackgroundImage : le fond de la tuile
  • Count : le chiffre qui sera indiqué dans le compteur en haut à droite (si 0 alors pas de compteur)

et donc 3 nouvelles propriétés correspondant à la face arrière :

  • BackTitle : le titre
  • BackContent : le contenu (Texte)
  • BackBackgroundImage : le fond de la tuile

<?xml version="1.0" encoding="utf-8"?>
<wp:Notification xmlns:wp="WPNotification">
 <wp:TileId="/Episodes.xaml?id=123">
 <wp:BackgroundImage>http://www.tvshowForWP7.com/images/21.jpg</wp:BackgroundImage>
 <wp:Count>21</wp:Count>
 <wp:Title>House M.D.</wp:Title>
 <wp:BackBackgroundImage>http://www.tvshowForWP7.com/images/back.jpg</wp:BackBackgroundImage>
 <wp:BackTitle>Lundi 13 mai</wp:BackTitle>
 <wp:BackContent>Prochain épisode : </wp:BackContent>
 </wp:Tile>
</wp:Notification>
Supprimer ou mettre à jour une tuile additionnelle avec Mango

Supprimer ou mettre à jour une tuile additionnelle avec Mango

On vient de voir dans l’article précédent comment ajouter une tuile, mais au cours de la vie de l’application, il sera parfois nécessaire de mettre à jour la tuile voir de la supprimer lorsque l’utilisateur aura supprimé une série/un favori/un vol, etc… de son application.

Le plus simple, est de se baser sur le navigationUri de la tuile, on va pour cela utiliser une requête Linq :

var mytile=ShellTile.ActiveTiles.FirstOrDefault(tile => tile.NavigationUri.ToString()=="/Episodes.xaml?id=13");
if(mytile==null)
return;

Attention, nous ne récupérons pas une référence vers une StandardTileData mais un objet de type ShellTile contenant principalement, une propriété NavigationUri et deux fonctions : Delete et Update.

Si on souhaite supprimer la tuile, il suffit d’appeler la méthode Delete() de la tuile.

mytile.Delete();

De même pour mettre à jour les informations de la tuile, il suffit de recréer un objet StandardTileData et de le passer à la méthode Update.

var newdata=new StandardTileData()
{
Title="Who is the doctor ?"
Background=new Uri("/img/backDoctor.png",UriKind.Relative);
}

mytile.Update(newdata);
Comment ajouter des tuiles additionnelles à son application

Comment ajouter des tuiles additionnelles à son application

Mango qui vient de sortir en beta pour les développeurs permet à une application d’avoir plusieurs tuiles. Une principale correspondant à ce qui existe actuellement mais aussi des tuiles annexes pouvant ainsi pointer sur une partie spécifique de l’application.

Si je prend l’exemple de TVShow, un de mes applications permettant de suivre et de gérer ses séries télé, on pourrait imaginer que l’utilisateur puisse “accrocher” à la page d’accueil une tuile “Desperate Housewives” ou “Doctor Who” qui lorsque l’on clique dessus, pointe directement vers les infos relatives à ces séries

Pour cela on utilise le nouvel objet ShellTile qui possède notamment une propriété ActiveTiles qui liste l’ensemble des tuiles utilisées par l’application.

Une tuile est représenté par un objet StandardTileData, avec comme propriétés :

pour la face avant :

  • Title : le titre qui sera affiché dans la partie inférieur gauche de la tuile
  • BackgroundImage : le fond de la tuile
  • Count : le chiffre qui sera indiqué dans le compteur en haut à droite (si 0 alors pas de compteur)

pour la face arrière :

  • BackTitle : le titre
  • BackContent : le contenu (Texte)
  • BackBackgroundImage : le fond de la tuile

Une fois cet objet créé, il suffit juste d’appeler la méthode ShellTile.Create avec en paramètre l’uri de la page qui sera affiché lorsque l’on cliquera sur cette tuile.

Exemple :

var newtile= new StandardTileData()
{
Title = "Doctor Who",
Count = 12,
BackgroundImage = new Uri("img/lost.jpg", UriKind.Relative),
BackTitle = "lundi 26 mai 2011",
BackContent = "prochain épisode",
BackBackgroundImage = new Uri("img/backtile.jpg", UriKind.Relative)
};

ShellTile.Create(new Uri("/Episode.xaml?id=123", UriKind.Relative), newtile);

Cacher automatiquement la systray dans windows phone 7

Cacher automatiquement la systray dans windows phone 7

Problématique

Lorsque l’on code une application en silverlight sous windows phone 7, nous avons la possibilité de laissé afficher ou de cacher la barre système en haut de l’écran.

La plupart des applications cachent cette barre, surement pour deux raisons :
– gagner de la place (32 pixels en mode portrait, 72 en mode paysage)
– cohérence graphique : si notre interface dispose d’une image de fond, une barre blanche ou noir en haut de l’écran peut être gênant

Néanmoins cette barre est indispensable à l’utilisateur, afin de connaitre l’heure, la disponibilité réseau, etc… Si l’utilisateur fait une recherche et que votre application n’affiche pas de résultats, sans cette barre, il ne va pas forcément penser à qu’il ne capte pas bien la 3G et dans sa tête, c’est votre application qui sera lente/bogué.

Pour conclure, les informations dans cette barre sont indispensables pour l’utilisateur et son expérience, mais peu m’embêter pour mon UI.

L’idée

Afin d’avoir le meilleur des deux mondes, l’idée est de cacher la systray par défaut, mais de laisser la possibilité à l’utilisateur de l’afficher lorsqu’il clique en haut de l’écran

 


A noter, on souhaite utiliser la vrai barre système, pas une fausse barre avec l’heure. De plus nous ne souhaitons pas que l’interface de l’application se décale lorsque la barre s’affiche.

La solution

Pour répondre à notre soucis, nous allons coder un behavior directement sur la PhoneApplicationPage.


public class SystrayBehavior : Behavior<PhoneApplicationPage>    {

...

}

et nous allons nous enregistrer sur l’évènement MouseLeftButtonUp de la page associé à notre behavior, tout en faisant attention de supprimer l’enregistrement dans la méthode appropriée.


protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.MouseLeftButtonDown += AssociatedObject_MouseLeftButtonUp;
}

protected override void OnDetaching()
{
AssociatedObject.MouseLeftButtonDown -= AssociatedObject_MouseLeftButtonUp;
base.OnDetaching();
}

nous allons donc écrire la méthode AssociatedObject_MouseLeftButtonUp qui va surveiller les évènements ‘touch’ et si un clic a lieu dans la zone supérieur de l’écran (32 pixels), on affiche la barre.

void AssociatedObject_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (e.GetPosition((UIElement)sender).Y <= 32)             {                 Microsoft.Phone.Shell.SystemTray.IsVisible = true;             }         } 	

Ceci dit, nous souhaitons qu’au bout de 3 secondes d’inactivité, la barre disparaisse. C’est à dire que si l’utilisateur clique plusieurs fois (par exemple pour faire un slide vers le bas pour afficher plus d’information sur la barre, on ne prend en compte que le dernier ‘clic’. On aurait pu utiliser RX pour cela, mais je utiliser le moins de dépendance possible, je me contenterais donc t’un dispatchTimer

                 DispatcherTimer tim = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(3) };                 tim.Tick += (senderr, er) =>
{
tim.Stop();
Microsoft.Phone.Shell.SystemTray.IsVisible = false;

};
tim.Start();

Si on lance notre application, voici le résultat :

 

Notre interface se décale lorsque la barre apparaît. En effet, la taille disponible pour l’affiche de la page diminue. Pour corriger cela, il faut trouver le bon moment pour décaler manuellement négativement notre page afin de compenser ce décalage.

Pour solutionner ce problème, on aurait tendance à modifier margin-top ou utiliser un translateTransform juste après ‘Microsoft.Phone.Shell.SystemTray.IsVisible = true;’ Cette solution n’est pas viable car il y a un delai entre l’affectation et le décalage effectif. Ceci va se traduire par des artefact, le page sera décalé vers le haut pendant quelques millisecondes et se remettra à sa place après.

Il faut donc utiliser un event afin de savoir que le décalage vient/va se faire.  Nous utiliserons donc l’évènement SizeChanged pour cela.


bool previousState;
void Associated_ObjectSizeChanged(object sender, SizeChangedEventArgs e)
{
if (previousState == Microsoft.Phone.Shell.SystemTray.IsVisible)
return;
previousState = Microsoft.Phone.Shell.SystemTray.IsVisible;
if (Microsoft.Phone.Shell.SystemTray.IsVisible)
AssociatedObject.Margin = new Thickness(0, -32, 0, 0);
else
AssociatedObject.Margin = new Thickness(0, 0, 0, 0);

}

On utilise une variable afin de garder en mémoire l’ancien état, on verifie si cet état a changé, si c’est le cas, on change la margin de notre page (on pourrait très bien utiliser un rendertransform aussi mais il peut y avoir des soucis si vous avez déjà des transformation dessus).

L’utiliser

 

Pour utiliser mon behavior, c’est assez simple, ajoutez une référence vers Huyn.Systray.dll, et dans votre Expression Blend, il suffit de glisser le composant ‘SystrayBehavior’ sur votre page. Il faudra aussi décocher “Show SystemTray” dans les propriétés de votre page.

Le futur

Actuellement le behavior ne prend en compte que le mode portrait, je suis en train de terminer un Toolkit avec d’autres contrôles tirés de TVShow, Fuse et mes autres applications. Le SystrayBehavior inclut prendra en compte le mode paysage.

Télécharger

 

La DLL ‘Huyn.Systray’

Le code source avec un exemple

 

Nouvelle version de Reactive Extensions

Nouvelle version de Reactive Extensions

La nouvelle version 1.0.10425 de la librairie Reactive Extensions vient de sortir et contient quelques modifications notoires.

Si vous souhaitez mettre à votre votre librairie ou tout simplement si vous êtes débutant et que vous ne comprenez pas pourquoi les exemples d’internet ne compile pas ou plante, voici quelques clés.

La fonction Observable.FromEvent(object,string) qui est largement utilisé pour associer un évènement comme Click ou MouseMove a été renommé, il faut maintenant utiliser Observable.FromEventPattern.

De même, si vous aviez l’habitude d’écrire :

 Observable.FromEvent<eventHandler, EventArgs>
                (h => h.Invoke,
                 h => myEvent += h,
                 h => myEvent -= h);

Sachez que le prototype du premier paramètre a évolué, il faudra écrire maintenant

 Observable.FromEvent<eventHandler, EventArgs>
                (h => (o,r)=> {ev(r);},
                 h => myEvent += h,
                 h => myEvent -= h);

Enfin, il semblerait que méthode

 Observable.FromEvent<eventHandler, EventArgs>
                (h => myEvent += h,
                 h => myEvent -= h);


ne semble plus fonctionner et lance une ArgumentException.

Voici le reste des changements :

Changelog

  • Fixed time delay in Window and Buffer operators
  • Fixed bug in GroupJoin
  • Fixed bug in Merge(n)
  • Renamed Window* to Window
  • Renamed Buffer* to Buffer
  • Renamed Generate* to Generate
  • Removed RemoveTimeInterval
  • Removed RemoveTimestamp
  • Removed Scan0
  • Removed Let on TValue
  • Ensured parity between Buffer and Window overloads, every overloads exists for both
  • Added absolute time scheduling to IScheduler
  • Renamed Join (as in the pattern) to When
  • Added overload to Sample that takes an IObservable
  • Moved TestScheduler to Microsoft.Reactive.Testing
  • Created ReactiveTest base type with useful members
  • Added state parameter to IScheduler schedule methods
  • Added additional overloads for First/Last/Single (OrDefault)
  • Added ElementAt
  • Added Distinct
  • Renamed FromEvent to FromEventPattern
  • Added FromEvent which converts from non-standard events to observables
  • Added ToEventPattern and IEventPatternSource
  • Added ToEvent and IEventSource
  • Improved performance of Task.ToObservable
  • Removed IEvent, Added EventPattern
  • Added ReactiveAssert class with common asserts in Microsoft.Reactive.Testing
  • Split release into Experimental and Stable
  • – Stable is only available on .NET 4, SL 4, and WP7
  • – Marked all parts of the API which are only available in Experimental with the ExperimentalAttribute
  • Improved Doc comments
  • Fixed a bug in Concat, OnErrorResumeNext, and Catch
  • Improved perf of subjects
  • Removed VirtualScheduler
  • Added VirtualTimeSchedulerBase, VirtualTimeScheduler
  • Added HistoricalSchedulerBase, HistoricalScheduler
  • Remove extended Action and Func Definitions in System.Reactive for downlevel platforms
  • Stopped shipping TPL 3.5
  • Temporarily not shipping System.Linq.Async, Ix, and RxJS
  • Added documentation for Microsoft.Reactive.Testing
  • Changed IScheduler interface, there are new extension methods on Scheduler which expose the old methods, but implementors will need to change; recursive and distributed scheduling
  • New Assembly structure:
  • – System.Reactive (what used to be CoreEx and Reactive)
  • – System.Reactive.Providers (Qbservable, IQbservable, and IQbservableProvider) – Observable.Provider is now Qbservable.Provider
  • – System.Reactive.Windows.Forms (all operators, schedulers, etc related to Windows Forms)
  • – System.Reactive.Windows.Threading (all operators, schedulers, etc related to WPF)
  • – Microsoft.Reactive.Testing (all code to assist in writing tests)
  • Third-party Qbservable extensibility
  • New namespace structure:
  • – System
  • – Reactive
  • – Linq
  • – Disposables
  • – Concurrency
  • – Joins
  • – Subjects
  • – Threading
  • – Tasks
  • – Windows
  • – Threading
  • – Forms
  • – Microsoft
  • – Reactive
  • – Testing
  • MutableDisposable changed to take an assignment policy
  • Reduced the memory consumption of CurrentThreadScheduler, VirtualTimeScheduler, HistoricalScheduler, and EventLoopScheduler
  • Reduced the memory consumption of many operators
  • Added Unit.Default
  • Added static class Subject with a few operators for Subjects
  • Removed CurrentThreadScheduler.EnsureTrampoline, Added CurrentThreadScheduler.ScheduleRequired
  • Added Observer.Synchronize
  • Made IObservable compatible with new Async CTP in the Experimental subset
  • Using await on IObservable now only returns the last message, if you want the old behavior use ToList first
  • Replaced all Subject* with FastSubject*, if you want old behavior then create a subject and use the Subject.Synchronize operator
  • Removed publish overloads that take a scheduler

 

Développer pour Microsoft Surface avec Windows 7 et VS2010

Développer pour Microsoft Surface avec Windows 7 et VS2010

Afin de développer pour Microsoft Surface il faut préalablement installer le Microsoft Surface SDK 1.0 SP1. Toutefois, si vous essayez de l’installer sur un Windows 7 avec Visual Studio 2010, un message d’erreur s’affichera.

Patcher l’installateur

L’installateur vérifie la présence de Visual Studio 2008 mais aussi de Vista. Donc si vous disposez de Windows 7 ou/et de Visual Studio 2010, il vous sera impossible de l’installer.

Toutefois, Visual Studio 2010 sait compiler en .Net 3.5, de plus toutes les applications pour Windows Vista fonctionne correctement avec Windows 7, on peut donc en déduire que cette limitation est un peu trop restrictive.

Pour corriger cela, voici un petit script en VBS qui va se contenter de supprimer l’instruction de vérification dans le fichier d’installation msi. Télécharger le script

Pour l’utiliser, il suffit de faire glisser le msi dessus.

Vous pouvez dès à présent lancer l’installation sans problème.

 

 

Déplacer les templates

 

Si vous lancez Visual Studio après l’installation, vous remarquerez qu’il n’y a pas de templates de projets pour surface.

Pour solutionner ce problème nous allons déplacer manuellement les fichiers de templates.

Allez dans le répertoire  Program FilesMicrosoft SDKsSurfacev1.0Project Templates et copiez les fichiers dans

%USERPROFILE%/DocumentsVisual Studio 2010TemplatesProjectTemplatesSurface (en créant préalablement le répertoire Surface).

De même pour les templates item :

Allez dans le répertoire  Program FilesMicrosoft SDKsSurfacev1.0Item Templates et copiez les fichiers dans

%USERPROFILE%/DocumentsVisual Studio 2010TemplatesItemTemplatesSurface (en créant préalablement le répertoire Surface).

templates de projets Surface
templates de composants Surface

Attention, il est indispensable de sélectionner Framework .Net 3.5 dans la liste déroulante en haut de la fenêtre quand vous créez votre projet !