Créer son OverlayIcon dynamique

Dans mon article parlant de mes premiers pas dans le WPF, je n’avais pas évoqué ce sujet. Voici donc venu l’occasion de le détailler.

Tout d’abord, de quoi parle-t-on?

Si vous avez lu mon article évoqué précédemment, vous avez peut-être remarqué que l’icône dans la barre de tâches contenait de l’information.

OverlayIcon

OverlayIcon

Le numéro présent sur l’icône affiche le nombre de Tweets que j’ai pu récupérer. Dans mon application WPF, celui-ci ne peut afficher qu’un maximum de 15 (Nombre maximum d’éléments récupérables via le service utilisé). Il est néanmoins possible d’y afficher différentes informations, pour autant que ça n’encombre pas trop l’affichage de l’icône.

Passons maintenant à la partie "Comment faire?":

  • 1. Le XAML.
  • Tout d’abord, on déclarera dans le XAML la structure de ce qu’on veut afficher dans l’OverlayIcon.

    <DataTemplate x:Key="OverlayIcon">
                <Grid Width="20" Height="20">
                    <Ellipse Fill="Red"
                            Stroke="White"
                            StrokeThickness="2"/>
    
                    <TextBlock Text="{Binding CountText}"
                            TextAlignment="Center"
                            Foreground="White"
                            FontWeight="Bold"
                            Height="16"
                            VerticalAlignment="Center"
                            FontSize="12">
                        <TextBlock.Effect>
                            <DropShadowEffect ShadowDepth="0" />
                        </TextBlock.Effect>
                    </TextBlock>
                </Grid>
            </DataTemplate>
    

    Explications :
    On déclare donc un template qu’on appliquera sur l’icône. Ce template sera composé d’une grid qui contiendra un cercle dans lequel on affichera un TextBlock. Ce dernier est bindé à CountText.

  • 2. Le Code Behind.
  • Dans le "Code Behind" de la page XAML, on crée une très simple classe ne contenant qu’une propriété qui servira au binding dans l’UI. Elle est déclarée au sein de la classe MainWindow.

    private class Context
            {
                public string CountText { get; set; }
            }
    

    Dans cette application, lorsque je récupère les Tweets, je fais appel à UpdateOverlayIcon() qui servira à calculer le nombre de Tweets présents dans la liste, à dessiner le cercle, assigner le DataContext approprié à notre élément dans le XAML et à assigner l’image dessinée à l’OverlayIcon.

    private void UpdateOverlayIcon()
            {
                //Hauteur et largeur de l'icône à générer
                int iconWidth = 20;
                int iconHeight = 20;
                //Création d'un nouveau context auquel on assignera la valeur du compteur
                Context context = new Context();
                if (_tweets.Count > 99)
                    context.CountText = "+";
                else
                    context.CountText = _tweets.Count.ToString();
                //Création de l'image à afficher dans l'icône
                RenderTargetBitmap bmp =
                    new RenderTargetBitmap(iconWidth, iconHeight, 96, 96, PixelFormats.Default);
                
                ContentControl root = new ContentControl();
                //On assigne le contexte crée plus tôt à la ressource du XAML
                root.ContentTemplate = ((DataTemplate)Resources["OverlayIcon"]);
                root.Content = context;
                
                root.Arrange(new Rect(0, 0, iconWidth, iconHeight));
                //Dessin de l'image instanciée précédemment
                bmp.Render(root);
                //Association de l'image avec l'icône
                TaskbarItemInfo.Overlay = (ImageSource)bmp;
            }
    

Vous êtes maintenant tous capables de créer une petite icône dynamique dans votre barre des tâches! :)

Session Advanced Windows Phone [Partie 1 : Data]

Cette fois-ci je vous présenterai un résumé de la session Advanced sur Windows Phone 8 donnée par Georges Legros et Loic Bar.

Cette première partie parlera surtout du stockage et chargement des données dans une application Windows Phone 8. Les parties suivantes couvriront l’Application Lifecycle, les Background Agents, et les LocalDB.

Il est possible d’interagir avec des données dans une application via:

  • APIs WindowsPhone7.1 Isolated Storage et l’IsolatedStorageSettings.
  • Le "Local Storage" et l’IsolatedStorage.
  • Le WindowsStorage.
  • Les "Special Folders" : Shared/Media, Shared/ShellContent et Shared/Transfers.
  • Les cartes SD externes (Lecture seulement).
  • Différentes manières d’accéder à un fichier dans WindowsPhone8.

-WP7.1 IsolatedStorage APIs

var isf = IsolatedStorageFile.GetUserStoreForApplication();
IsolatedStorageFileStream fs = new IsolatedStorageFileStream("CaptainsLog.store", FileMode.Open, isf));

-WP8 Storage APIs using URI

StorageFile storageFile = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(                        new Uri("ms-appdata:///local/CaptainsLog.store "));

-WP8 Storage APIs

Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;Windows.Storage.StorageFile storageFile = await localFolder.GetFileAsync("CaptainsLog.store");
  • 1. Accès aux données en utilisant les WP7.1 Isolated Storage APIs.
  • Les classes IsolatedStorage font toutes partie du namespace System.IO.IsolatedStorage
    -IsolatedStorageFile : Représente un espace de stockage contenant des dossiers et des fichiers.
    -IsolatedStorageStream : Mets à disposition un "file stream accès" vers un ficher stocké à l’intérieur de l’IsolatedStorage.
    -IsolatedStorageSettings : Dictionnaire sauvegardant des paires clé-valeur dans l’IsolatedStorage

    • 1.1 Sauvegarde de données
    • private void saveGameToIsolatedStorage(string message)
      {
        using (IsolatedStorageFile isf =
               IsolatedStorageFile.GetUserStoreForApplication())
        {
          using (IsolatedStorageFileStream rawStream = isf.CreateFile("MyFile.store"))
          {
             StreamWriter writer = new StreamWriter(rawStream);
             writer.WriteLine(message); // save the message
             writer.Close();
          }
        }
      }
      

    • 1.2 Chargement de données
    • private string loadString()
      {
        string result = null;
        using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
        {
          if (isf.FileExists("Myfile.store")
          {
            using (IsolatedStorageFileStream rawStream = isf.OpenFile(filename,                                                                 System.IO.FileMode.Open))       {
              StreamReader reader = new StreamReader(rawStream);
              result = reader.ReadLine();
              reader.Close();
            }    }
        }
        return result;
      }
      

  • 2. Utilisation de l’IsolatedStorage
    • 2.1 Sauvegarde de données dans l’espace de configuration
    • Dans le cas où l’on veut sauvegarder de simples informations de configuration (exemple : un username), on peut utiliser l’objet ApplicationSettings dans IsolatedStorage et l’utiliser comme un dictionnaire.

      void saveString(string message, string name)
      {
          IsolatedStorageSettings.ApplicationSettings[name] = message;
          IsolatedStorageSettings.ApplicationSettings.Save();
      }
      

      Il faut juste faire attention à faire appel au .Save() après avoir ajouté toutes les clés souhaitées.

    • 2.2 Chargement de données depuis l’espace de configuration
    • string loadString(string name)
      {
          if (IsolatedStorageSettings.ApplicationSettings.Contains(name))
          {
              return (string)IsolatedStorageSettings.ApplicationSettings[name];
          }
          else
          {
              return null;
          }
      }
      

      Il faut juste faire attention à tester la clé que l’on souhaite récupérer si on ne veut pas risquer de recevoir une exception.

  • 3. En utilisant le Windows Phone Runtime Storage.
    • Les classes Windows Phone Runtime Storage sont dans le namespace Windows.Storage.
      -StorageFolder : Représente une zone de stockage contenant des fichiers et des répertoires.
      -StorageFile : Représente un fichier et fournit des méthodes permettant de le manipuler.

    • 3.1 Sauvegarde de données en utilisant StorageFolder.
    • using System.IO;
      using Windows.Storage;
      …
      
      private async void saveToLocalFolderAsync(string message)
      {
           // Get a reference to the Local Folder
           StorageFolder localFolder = ApplicationData.Current.LocalFolder;
      
          // Create the file in the local folder, or if it already exists, just open it
          StorageFile storageFile = await localFolder.CreateFileAsync("Myfile.store",                                          CreationCollisionOption.OpenIfExists);
      
          Stream writeStream = await storageFile.OpenStreamForWriteAsync();
          using (StreamWriter writer = new StreamWriter(writeStream))
          {
              await writer.WriteAsync(logData);
          }}
      

    • 3.2 Chargement de données.
    • using System.IO;
      using Windows.Storage;
      …
      
      private async string loadStringAsync()
      {
          string theData = string.Empty;
      
          // Get a reference to the file in the Local Folder
          StorageFolder localFolder = ApplicationData.Current.LocalFolder;    StorageFile storageFile = await localFolder.GetFileAsync(“Myfile.store"));
      
          // Open it and read the contents
          Stream readStream = await storageFile.OpenStreamForReadAsync();
          using (StreamReader reader = new StreamReader(readStream))
          {
              theData = await reader.ReadToEndAsync();
          }
      
          return theData;
      }
      

  • 4. Accéder à des fichiers en utilisant ms-appdata:///local ou ms-appx:///.
  •   // There's no FileExists method in WinRT, so have to try to open it and catch exception instead
      StorageFile storageFile = null;
      bool fileExists = false;
    
      try
      {
        // Try to open file using URI
        storageFile = await StorageFile.GetFileFromApplicationUriAsync(
                        new Uri("ms-appdata:///local/Myfile.store"));
        fileExists = true;
      }
      catch (FileNotFoundException)
      {
        fileExists = false;
      }
    
      if (!fileExists)
      {
        await ApplicationData.Current.LocalFolder.CreateFileAsync("Myfile.store",                           CreationCollisionOption.FailIfExists);
      }
    

    REMARQUE :
    En Windows Phone 8 (contrairement à Windows 8), nous n’avons pas accès à différents éléments :

    • Roamind Data Store
    • Temporary Data Store
    • Local Settings
    • Roaming Settings
  • 5. Accéder à des données en utilisant Windows.Storage.
    • 5.1 En utilisant les SpeciaFolders.
    • Tout d’abord, il faut dire que les opérations de lecture-écriture I/O sont limitées au dossier local de l’application.
      Dans ce « local folder », il y a des dossiers réservés : à l’intérieur de ce dernier, il y a un dossier « Shared » qui lui contient un dossier Media, un dossier ShellContent et un dossier Transfers. Ces trois dossiers ont chacun une utilité bien spécifique.

      • 5.1.1 Shared/Media
      • Ce dossier peut être utilisé par l’application des images relatives aux musiques qui seront utilisées dans l’ "Universal Volume Control" (UVC). Ceci peut être utile dans le cas d’une application de type Media Player.

      • 5.1.2 ShellContent
      • Les images d’arrière-plan des Tiles (tuiles) peuvent être stockées dans l’IsolatedStorage mais doivent être placées dans ce dossier ou un sous-dossier.

      • 5.1.3 Shared
      • Zone de stockage utilisée par le Background File Transfer Service.

  • 6. Sérialisation et désérialisation des données
  • On va ici analyser la sérialisation et désérialisation des données dans le contexte de l’application lifecycle.

    • Lancement de l’application
    • Il faut ici désérialiser les données depuis l’IsolatedStorage.

    • Passage de l’application en état Dormant/Tombstoned
    • Ici, il faudra penser à sérialiser les données vers l’IsolatedStorage.

    • L’application est réactivée
    • Désérialiser les données de l’IsolatedStorage.

    • L’application est terminée
    • Sérialiser les données vers l’IsolatedStorage.

    Pourquoi faudrait-il sérialiser les données d’une application?
    Les sérialiseurs écrivent les propriétés d’une collection d’objets dans un fichier afin qu’elles puissent être stockées de manière persistante.
    Les désérialiseurs font exactement l’inverse : ils lisent des données depuis un fichier et utilisent ceci pour repopuler une collection d’objets en mémoire.

    • Sérialisation de données en utilisant DataContractSerializer
    • Voici une classe utilisée à la sérialisation très générique, il faut bien sûr l’adapter pour qu’elle soit appropriée à vos objets.

      public class MyDataSerializer<TheDataType>
          {
              public static async Task SaveObjectsAsync(TheDataType sourceData, String targetFileName)
              {
                  StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(
                      targetFileName, CreationCollisionOption.ReplaceExisting);
                  var outStream = await file.OpenStreamForWriteAsync();
      
                  DataContractSerializer serializer = new DataContractSerializer(typeof(TheDataType));
                  serializer.WriteObject(outStream, sourceData);
                  await outStream.FlushAsync();
                  outStream.Close();
              }
      
              ...    }
      

      Pour faire appel à cette méthode de sérialisation :

      List<MyDataObjects> myObjects = ...     
      await MyDataSerializer<List<MyDataObjects>>.SaveObjectsAsync(myObjects, "MySerializedObjects.xml");
      

    • Sérialisation de données en utilisant DataContractSerializer
    • Encore une fois, nous allons reprendre une classe très générique pour la sérialisation de données :

          public class MyDataSerializer<TheDataType>
          {
              public static async Task<TheDataType> RestoreObjectsAsync(string fileName)
              {
                  StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName);
                  var inStream = await file.OpenStreamForReadAsync();
      
                  // Deserialize the objects. 
                  DataContractSerializer serializer =
                      new DataContractSerializer(typeof(TheDataType));
                  TheDataType data = (TheDataType)serializer.ReadObject(inStream);
                  inStream.Close();
      
                  return data;
              }
              ...    }
      

      Il faut ensuite faire appel à la méthode:

      List<MyDataObjects> myObjects
          = await MyDataSerializer<List<MyDataObjects>>.RestoreObjectsAsync("MySerializedObjects.xml");
      

  • 7. Isolated Storage Explorer tool.
  • Commençons par voir comment observer l’évolution de nos données contenues au sein de l’IsolatedStorage. Afin de pouvoir voir l’état du data, on peut utiliser un outil assez pratique :
    Isolated Storage Explorer : c’est un outil à utiliser avec le "Command Prompt".
    Le plus simple pour comprendre son utilisation, je vous conseille de consulter le lien msdn qui explique son utilisation de manière complète et compréhensible : Lien MSDN.

  • 8. Accéder aux cartes SD externes
  • Les appareils Windows Phone 8 supportent l’utilisation de cartes SD. Les applications offrent la possibilité d’accéder aux fichiers stockés sur une carte SD externe si le développeur a déclaré ID_CAP_REMOVABLE_STORAGE dans l’application manifest.
    L’application n’aura aussi que des droits de lecture, on ne peut avoir qu’un accès en lecture aux fichiers présents sur le support externe. Une autre restriction est que l’application n’a accès qu’aux fichiers d’un certain type. Celui-ci doit être déclaré dans le WMAppManifest.xml de l’application. Les autres types de fichiers seront également inaccessibles, ceci pour garantir une certaine sécurité des données de l’utilisateur.
    Pour déclarer que l’application utilisera un certain type de fichier, il est nécessaire de le déclarer comme ceci.

    <Extensions>  <FileTypeAssociation Name=“foo" TaskID="_default" NavUriFragment="fileToken=%s">    <SupportedFileTypes>      <FileType ContentType="application/foo">.foo</FileType>    </SupportedFileTypes>  </FileTypeAssociation></Extensions>
    

    Différentes APIs sont disponibles pour permettre un accès à un stockage externe :

    • ExternalStorageDevice :
    • Représente une carte SD de manière unique en utilisantExternalStorageDeviceExternalStorageID().

    • ExternalStorage.GetExternalStorageDevicesAsync()
    • Retourne une collection des cartes SD insérées dans le téléphone.

    • ExternalStorageFolder
    • Représente un dossier présent sur la carte SD externe. Pour accéder à ce dossier plus tard dans l’application, il faut utiliser ExternalStorageFolderPath().

    • ExternalStorageFile
    • Représente un fichier présent sur la carte SD. Pour accéder à ce fichier plus tard dans l’application, il faut utiliser ExternalStorageFilePath().

    • ExternalStorageDeviceGetFile Async() et ExternalStorageDeviceGetFolder Async()
    • Permet d’obtenir un fichier ou un dossier directement depuis l’objet de stockage externe.

  • 9. Best Practices
  • Il faut faire attention à plusieurs éléments lors du stockage de données sur Windows Phone. Il faut savoir qu’il n’y a pas de quota : on n’a donc pas de limite par rapport à la quantité d’informations que l’on stocke sur le téléphone à partir d’une application. Ceci est un avantage pour les développeurs, mais il faut faire attention à ne stocker que les informations nécessaires afin de ne pas surcharger la mémoire du téléphone. Il est aussi préconisé de supprimer les fichiers temporaires et ceux qui ne sont plus utiles.
    Si l’application a besoin de beaucoup d’espace en mémoire, il peut être préférable d’archiver ces données dans le cloud.
    Lorsque l’on charge des données complexes, il vaut vraiment mieux les charger dans un Thread séparé de celui de l’UI (User Interface) afin de ne pas bloquer l’application.

    Les prochaines parties de cette présentation seront publiées dans le courant de la semaine.

    Premiers pas dans le monde du WPF

    Actuellement en pleine préparation d’un exposé concernant le WPF, j’ai eu l’occasion de faire quelques petits pas dans ce nouveau monde.
    Ce que j’ai remarqué avant tout c’est qu’on se retrouve dans un environnement qui est fort ressemblant à ce à quoi on est habitué à voir dans l’environnement Windows 8, c’est à dire des fenêtres construites à l’aide du langage déclaratif XAML qui sont épaulées par du code behind C#.

    Trop impatient pour passer trop de temps à me limiter à lire de la documentation, je me suis décidé de me plonger dans le développement d’une (pour l’instant il n’y en a qu’une) petite application afin de mettre les mains dedans. Après tout, c’est la meilleure façon de découvrir des choses.

    Dans ma première étape de recherche, je suis tombé sur un service Twitter permettant de récupérer les 15 Tweets les plus récents dans lesquels on pourra trouver une chaine de caractère passée en paramètre dans l’URL.

    Voici l’URL en question : http://search.twitter.com/search.json?q=micbelgique

    Si vous suivez ce lien, vous pourrez remarquer qu’il nous retourne du Json. On se servira de toutes ces données, disposées en "brut" sur la page dans notre application.

    Première question : "Comment?".
    La toute première chose à faire c’est de se documenter à propos de l’utilisation d’une WebApi retournant du Json.

    http://www.codeproject.com/Tips/397574/Use-Csharp-to-get-JSON-data-from-the-web-and-map-i

    En suivant ce tuto, on commencera tout d’abord par créer son modèle.

    Petit tips du jour : il est possible de générer les classes du modèle (relatives au données Json) automatiquement.

    Bien que, dans ce projet-ci, le modèle se révèle suffisant, cette génération automatique ne fait que nous donner une base sur laquelle démarrer, il faut revoir cette dernière pour être sûr qu’elle soit adaptée à notre projet, sinon on pourrait se retrouver nez à nez avec des erreurs de cast et/ou de conception de modèle.

    http://at-my-window.blogspot.be/2010/11/json-c-class-generator.html

    Une fois généré, on se retrouve directement avec notre modèle composé d’une classe principale composée d’une liste "Results". Results représente la liste des tweets résultants à notre recherche.

    La propriété qu’on retient pour le moment est donc la suivante :

    public IList<Result> Results { get; set; }
    

    Un Result est quant à lui composé de toute une série de propriétés qu’on peut toutes utiliser dans notre programme.
    Pour ma part j’ai retenu les suivantes :

    public string FromUserName { get; set; }
    
    public string ProfileImageUrl { get; set; }
    
    public string Text { get; set; }
    

    Il est dés lors possible et très simple d’obtenir les données dans une liste.

    private ObservableCollection<Result> _tweets = new ObservableCollection<Result>();
    var url = "http://search.twitter.com/search.json?q=" + TweetBox.Text;
    //méthode issue du tutorial
    var items = _download_serialized_json_data<Tweet>(url);
    //parcours des résultats et ajout dans une collectionObservable afin de pouvoir binder les données
    foreach(Result t in items.Results)
    {
          _tweets.Add(t);
    }
    

    On peut maintenant binder les données à une ListBox par exemple, en bindant les contrôles appropriés aux propriétés ProfileImageUrl et Text.

    Personnellement, j’ai utilisé la propriété FromUserName uniquement pour faire un tri sur l’auteur du Tweet afin de pouvoir générer un petit graphique représentant le nombre de tweets par personne (dans les 15 tweets récupérés, logiquement).

    Le graphique a été généré grâce à chartingToolkit.

    Il est aussi possible de binder le graphique à une liste afin qu’il soit mis à jour lors de la mise à jour de données.

    foreach (Tweeter tweeter in tweeters)
    {
          valueList.Add(new KeyValuePair<string,int>(tweeter.getName(),tweeter.getTweetCount()));
    }
    pieChart.DataContext = valueList;
    

    Il faut juste être attentif à un élément : lorsque qu’on .Clear() la liste d’items bindée au graphique, ce dernier ne se remettra pas à son état vide automatiquement.
    Pour contourner ceci,

    pieChart.DataContext = null;
    

    Le résultat final de cette petite ballade dans le monde du WPF :

    Application obtenue

    Application obtenue

    N’hésitez pas à me faire parvenir du feedback si jamais vous avez une remarque à faire par rapport à mes articles ou autre :)

    A bientôt.

    Session Discovery Windows 8

    Donnée par Renaud Dumont, cette journée de formation fut un premier abord au développement d’applications destinées au store Windows 8.

    Liste des sujets abordés lors de cette journée :

    • Présentation de la plateforme Windows 8.

    La session a commencé par une présentation de l’environnement Windows 8, de ses fonctionnalités, de l’expérience utilisateur que procure celui-ci (UX que l’on est sensé retrouver dans les applications que l’on souhaite publier sur le store).

    • Design Guidelines pour Windows 8.

    L’expression que l’on retiens de cette partie est "Content before chrome". Ceci va à l’encontre de ce que l’ont retrouvais sur Windows 7, c’est-à-dire plein de petits widgets, de la transparence, des bord bien arrondis le tout dans des applications fenêtrées.
    Dans le nouvel environnement proposé par Microsoft, on va essayer de mettre le contenu le plus en avant possible. On remplacera les grands menus défilants par des options (situées au même endroit dans chaque application du store).Le contenu ne sera dorénavant plus caché derrière une multitude de boutons, le contenu est affiché dés le départ. Les éléments de navigation sont également, si possible, rempli de contenu.

    • Développement d’applications Windows 8 en HTML5.

    Il est maintenant possible de développer ses application pour le store en HTML5/CSS pour les développeurs web, ainsi qu’en C++ pour les plus courageux d’entre vous.

    • Développement d’application Windows 8 en C#.

    Les habitués pourront bien sûr continuer à développer en C#/XAML, avec le framework .Net 4.5.

    • Différents contrôles disponibles.

    Une multitude de contrôles est disponible dans Visual Studio, directement drag-and-droppable dans le designer XAML, pour les habitués, pas grand chose de nouveau à ce niveau là.

    • Notion de contrats nécessaires à l’élaboration d’une application complète.

    Les contrats sont une nécessité pour le développement des fonctionnalités suivantes :
    -Search : Rend l’application "Searchable" depuis n’importe où dans le système.
    -Share : Permet le partage de données entre applications.
    -Settings : Permet un accès rapide et contextuel aux paramètres de l’application.
    -Play To : Permet à l’application de "stream" de l’audio, des vidéos et des image vers un "receiver" de "Play To" certifié.
    -App to App Picking : Permet à l’utilisateur d’utiliser des fichiers directement depuis une autre application.

    • Application Lifetime Management.

    Tout d’abord je vais parler des différents cas de figure :

    Schéma de l'Application LifeTime Management

    Schéma de l’Application LifeTime Management

    En tant que développeur, il faut gérer le comportement que doit adopter l’application lorsque celle-ci change d’état.

    Différents scénarios :

    1/ Lancement de l’application
    L’état de l’application passe de NotRunning à Running. Cette transition peut avoir lieu si l’application est exécutée :
    – pour la première fois ;
    – après un crash ;
    – après avoir été terminée par l’operating system.

    Lors du lancement de l’application, un SplashScreen est affiché. Lors de l’affichage de celui-ci l’objectif principal est de charger l’Interface Utilisateur de l’application. Si des chargements/téléchargements de données doivent être faits, il faut le faire après cet écran de chargement (En affichant une animation de chargement par exemple).

    2/ Activation de l’application
    L’application peut être activée par toute une série de contrats et d’extensions. Afin que l’application soit activée par un de ceux-ci, elle doit être répertoriée comme pouvant être activée par ce contrat/extension.
    On peut également récupérer l’état actuel de l’application pour vérifier si l’application est actuellement en exécution ou pas.
    L’activation de l’application peut également être utilisée pour charger des données sauvegardées lors d’une exécution précédente.
    On peut également récupérer l’état de la dernière exécution en accédant à la valeur de la propriété PreviousExecutionState.

    Cette propriété peut prendre 3 valeurs différentes :
    * Terminated : Signifie que l’application a été terminée par le système (par manque de ressources par exemple). Dans ce cas-ci il faut recharger les données de la dernière exécution.
    REMARQUE : Il n’y a aucun moyen d’exécuter du code lorsque une application est terminée par le système. Les données doivent doit être enregistrées lorsque l’application est suspendue.
    * ClosedByUser : Comme la valeur l’indique, l’exécution de l’application a été interrompue par l’utilisateur. On chargera donc pour la plupart des cas l’application avec les données par défaut.
    * NotRunning : L’exécution de l’application a été suspendue de manière non prévue. Il faudra charger l’application avec les données par défaut.

    3/ Suspension de l’application
    L’application est suspendue lorsqu’elle est n’est plus en avant plan, c’est-à-dire que l’utilisateur utilise une autre application ou lorsque la réserve de batterie du device s’épuise.
    C’est ici que nous devrons prévoir la sauvegarde de toutes les données, on nous accorde en effet 5 secondes pour faire toutes nos manipulations. Si il faut uploader des données ou faire des traitements plus longs, il peut être possible de faire ceci dans un background agent.

    4/ L’application est résumée
    Lorsque l’utilisateur a mis une application en arrière-plan et que par la suite il décide de la repasser en premier plan, elle sera rechargée exactement dans le même état que dans la dernière fois vu qu’elle est gardée en mémoire. On sous-entends ici qu’elle n’a pas été terminée par le système entre temps.

    5/ L’application est fermée
    Lorsque l’utilisateur décide de fermer l’application nous disposons de 10 secondes de temps d’exécution afin d’effectuer tous les traitements nécessaires.

    6/ Désinstallation de l’application
    Lors de la désinstallation d’une application, tous les fichiers du programme sont supprimés mis à part les fichiers de l’utilisateur (Les documents générés par l’application par exemple).

    • Tiles, LiveTiles et Secondary tiles.

    Les tiles du menu Windows 8 diffèrent des icônes classiques auxquelles nous sommes habitués. Les tiles nous donnent déjà certaines informations à propos de l’application.
    Cette tile peut également être mise à jour grâce à des PUSH notifications ou une "ScheduledTask". Il s’agit dans ce cas alors d’une live tile.
    Les secondary tiles sont des tiles générées depuis une applications. Il s’agit alors d’un raccourcis vers une certaine partie de l’application.

    • Interraction avec le hardware disponible (en fonction des différents capteurs disponibles).

    Il est très facile d’interagir avec les différents capteurs du device et en récupérer des informations ou des flux d’informations (Caméra, micro, …).

    • Présentation du store.

    Pour ceux qui sont habitués au store WindowsPhone, il retrouveront un store assez ressemblant, avec ses procédures de validation, de vente d’application, de suivi d’application,…
    Il est à noter que le store est commun entre Windows 8 "classiques" et Windows 8 RT (tablette). Le développeur choisira s’il veut publier uniquement sur une plateforme ou les deux).

    • Très courte présentation des mobile services.

    "Très courte" car après avoir assisté à la session Windows Azure Advanced on découvre l’énorme potentiel de cet outil. Windows Azure sera abordé dans un article suivant dans lequel on se plongera sur les fonctionnalités de la plateforme.Voici la fin de ce premier article informatif, d’autres sujets seront abordés, soon.

    Début d’une nouvelle aventure…

    Aujourd’hui débute officiellement le stage chez le groupe Rossel encadré par le Microsoft Innovation Center (MIC).

    Ce premier jour ne fait que nous mettre l’eau à la bouche : annonces pratiques sur la gestion du projet (Adoption du système Scrum), quelques infos sur la vie pratique au MIC ainsi que la présentation de certaines opportunités tel que la possibilité d’assister au TechDays, le passage de certifications Microsoft, …

    Demain est prévue notre (Kévin Bastin et moi-même) arrivée au groupe Rossel où nous allons passer la plupart du temps.

    L’impatience d’apprendre et de découvrir résume au mieux le ressentit du jour!