http://lazywormapps.com/metrotube-URI-schema.html

This is cool, but personally, I won’t do that, cause I trust only the official player for several reasons:

• It’s supported by Microsoft, more stable and less risky, ‘Metro tube’ using a hack to retrieve Urls of the mp4 video, it happened several times in the past that the application no longer works for days, a good way to have negative comments in your own application.
• There is a risk that the application be removed by Youtube for non-compliance with the youtube TOS
• Metro tube is a paid application, I do not want to impose this on my users.
• Other apps can use the same protocol extension and can be crappy

How to launch the official player?

For this, you only need to use the protocol extension of the official application: vnd.youtube.

So create a launcher et use the youtube video id as a parameter.

For example, the video id of http://www.youtube.com/watch?v=9bZkp7q19f0 is ’9bZkp7q19f0′ :

Windows.System.Launcher.LaunchUriAsync(

new System.Uri("vnd.youtube:9bZkp7q19f0")

);

Les développeurs de l’application Metro tube font actuellement la promo de leur app en proposant aux développeurs tierces d’utiliser le protocole d’extension pour lancer leurs apps au lien d’intégrer un player youtube directement dans son application.

http://lazywormapps.com/metrotube-uri-schema.html

La chose est louable, mais personnellement, je ne ferais confiance qu’au player officiel pour plusieurs raisons :

• Il est supporté par Microsoft, donc beaucoup plus stable, Metro tube utilisant un hack pour récupérer les uri des vidéos, il est arrivé plusieurs fois dans le passé que l’application ne fonctionne plus pendant des jours, un bon moyen pour avoir des commentaires négatifs dans sa propre application sans en être la case
• Un risque existe que l’application soit retiré du jour au lendemain du Store pour non respect des TOS de youtube
• Metro tube est une application payante, je ne souhaite pas imposer cela à mes utilisateurs.
• N’importe quel autre app peut se brancher sur le même protocole que metro tube et avoir une qualité bcp moindre

La question maintenant est :

Comment lancer le player officiel ?

Pour cela, il suffit d’utiliser le protocole d’extension réservé à l’application officielle youtube : vnd.youtube.

Créez juste un launcher et passez en paramètre l’identifiant de votre vidéo youtube.

Par exemple, pour la vidéo http://www.youtube.com/watch?v=9bZkp7q19f0, son id est 9bZkp7q19f0 et on peut la lancer en écrivant :

Windows.System.Launcher.LaunchUriAsync(

new System.Uri("vnd.youtube:9bZkp7q19f0")

);

Ce mini article va mettre en avant quelques fonctionnalités cachées du webbrowser en passant notammment par la classe d’extension WebBrowserExtensions.

WebBrowserExtensions contient 3 méthodes qui rendraient jaloux tous les développeurs Windows 8

GetCookies 

Cette méthode permet de récupérer les cookies d’un contrôle browser de votre application. Il vous sera impossible de récupérer les cookies de l’application « Internet Explorer » du téléphone, votre application et l’application Internet Explorer étant toutes les deux sandboxées. Même s’il faut passer un webbrowser en paramètre, les cookies sont gérées de façon globale dans votre application. Il sera impossible de récupérer les cookies http only via cette méthode.

ClearCookiesAsync

Cette méthode va vous permettre d’effacer les cookies, c’est l’antagonisme de la première, elle permet d’effacer l’ensemble des cookies de votre application. A noter, c’est un tout ou rien, impossible de supprimer qu’une partie des cookies.

ClearInternetCacheAsync

La dernière et non des moindres va vous permettre de supprimer l’ensemble du cache http de votre application, celui-ci étant utilisé quand une page/un script/une image est retournée avec l’attribut cache-control. Comme ClearCookiesAsync, c’est tout ou rien, attention donc.

Saviez-vous que depuis Windows Phone 8, il est possible de récupérer la liste de vos applications que l’utilisateur possède sur son téléphone ? Maintenant oui, et plus fort il est possible d’avoir aussi des informations afin de savoir si l’application est en cours d’installation ou déjà installée et encore mieux ! Vous pourrez récupérer la date d’installation de l’application ou encore le numéro de version et même l’icone de l’app : MAGIQUE !

Et le meilleur pour la fin : vous avez la possibilité de lancer l’application sans recourir à l’extension de protocole !!!!

Lister les applications de l’auteur sur le téléphone

Cela se fait très simplement :

foreach(var package in InstallationManager.FindPackagesForCurrentPublisher())
{
MessageBox.Show(package.InstallDate + " " + package.Id.Name);

}

Rechercher une application

Package SearchApp(String productId)
{
return InstallationManager.FindPackagesForCurrentPublisher().FirstOrDefault(app => app.Id.ProductId == productId);
}

Lancer une application

{

var package=SearchApp("{91000C5C-9943-43B7-AB65-7609D91057EF}");
package.Launch();

}

Allons encore un peu plus loin, on sait maintenant lancer une application, maintenant voyons comment lancer une page bien précise de votre application !

lancer une page spécifique d’une application

{

var package=SearchApp("{91000C5C-9943-43B7-AB65-7609D91057EF}");
package.Launch("/AboutPage.xaml);

}

On a donc une possibilité de manipulation assez extraordinaire ! En plus de spécifier la page, vous pouvez aussi spécifier des paramètres comme par exemple :

{

var package=SearchApp("{91000C5C-9943-43B7-AB65-7609D91057EF}");
package.Launch("/FluxRSSPage.xaml?uri=rudyhuyn.com");

}

Récupérer l’icône de l’application

{

var package=SearchApp("{91000C5C-9943-43B7-AB65-7609D91057EF}");

var token = package.GetThumbnailToken();

var name = SharedStorageAccessManager.GetSharedFileName(token);

await SharedStorageAccessManager.CopySharedFileAsync(ApplicationData.Current.LocalFolder, name, NameCollisionOption.ReplaceExisting, token);

using (var file = IsolatedStorageFile.GetUserStoreForApplication().OpenFile(name, FileMode.Open, FileAccess.Read))
{
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(file);
MonImage.Source = bitmap;
}

}

Et comment faire fonctionner ceci quand mon application n’est pas sur le store ?

En effet, il y a de grandes chances que votre publisher Id de vos application ne correspond pas avec votre publisher id du Store.

Lorsque vous soumettez une application, le Store remplace automatiquement le publisher id de vos apps par celui du store, nous allons donc tout simplement remplacer le publisher ID que visual studio a généré par le votre, pour cela commencez par le récupérer sur la page suivante :

https://dev.windowsphone.com/en-us/account

puis ouvrez le fichier WMAppManifest.xml de votre application, allez dans l’onglet Packaging et remplacez le Publisher Id par le votre (en n’oubliant pas les accolades)

Vous aurez maintenant la possibilité de lister vos autres applications provenant du store.

Puis je lancer une application ne m’appartenant pas ?

Non, pour des raisons évidente de sécurité !

Conclusion

Énormément de scénario peuvent découler de ces APIs, quelques exemples en vrac :

- permettre l’accès à des fonctionnalités uniquement si l’utilisateur possède une autre de vos apps

- afficher un message de remerciement : « vous utilisez 4 de nos applications, merci beaucoup, voulez-vous découvrir nos autres applications ? »

- permettre le lancement d’une de vos apps sans exposer publiquement une extension de protocole, vous sécurisez ainsi les communications

- avoir des pages cachées dans vos applications, uniquement accessible depuis une autre de vos apps

- etc…

ff

Invitation à lancer un webbrowser pour participer à un concours

Ouvre le Windows Phone Store pour télécharger une application

Pour cela la technique est assez simple, à chaque démarrage, l’application fait une requête sur mon serveur en passant sa culture (anglais, français, etc…), et récupère des variables : image url, texte descriptif et le lien.

Selon le type du lien, je lance alors : une page interne de l’application (pour faire découvrir un article bien précis, pour faire découvrir les settings, etc…), un lien internet via un WebBrowserTask ou une page du Windows Phone Store via un MarketplaceDetailTask.

Toutefois, la mise en forme reste assez statique et pour la prochaine version je veux aller en plus en injectant directement du XAML dans la page ! On pourra alors imaginer avoir des animations spécifiques, des sliders, etc…

Comment le faire ?

C’est très très simple, il suffit en fait d’utiliser un XamlReader, et notamment  sa méthode Load qui va permettre de lire du code xaml depuis une string et de générer les différents objets XAML.

Dans l’exemple suivant, nous allons appeler une page php qui va nous fournir du code xaml selon notre culture. Nous donnerons le résultat de cette requête au XamlReader et nous afficherons le résultat dans un panel XAML nommé CommentPanel.

WebClient web = new WebClient();
web.DownloadStringCompleted += (sender, e) =>{
try
{
var xaml = XamlReader.Load(e.Result);
CommentPanel.Content = xaml;
}
catch
{
}

};
web.DownloadStringAsync(new Uri(uri+"?culture="+CultureInfo.CurrentUICulture.TwoLetterISOLanguageName,UriKind.Absolute));

et du côté PHP :

<?php
$culture=$_GET['culture'];
if($culture=='fr'){
?>

<StackPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<Button Content="Click Me" />
<Slider Minimum="0" Maximum="100" />
</StackPanel>
<?php }else
{
?>
<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Background="Red" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<TextBox />
</Grid>
<?php } ?>

Et ça fonctionne !!

A noter : pensez bien à définir les namespaces sans oublier le namespace par défaut, sinon vous recevrez une exception pendant le chargement du XAML.

Comment rendre ceci interactif ?

Il n’est pas possible en effet d’inclure du code-behind dans cette injection afin d’interagir avec les nouveaux éléments XAML (par exemple afficher une page web quand on clique sur un bouton ou lancer une animation), il y a plusieurs solutions.

Pour afficher une page web ou une page interne de votre application, vous pouvez vous reposer sur les spécificités du contrôle HyperlinkButton par exemple :

<HyperlinkButton NavigateUri="http://www.bing.com" />

Une autre solution est de binding vos contrôles à des commandes, en effet, il n’est pas possible de se lier à des event handlers directement comme :

<Button Click="ClickAction" />

Binding ?

Les bindings fonctionnent évidemment ! Vous pouvez écrire sans soucis :

<Button Content="{Binding MyTitle}" />

Toutefois, vous ne pourrez faire référence à des éléments de votre page dans vos bindings (mais vous pouvez référer des éléments de votre XAML dynamique.

Note

Evidemment, vous ne pouvez pas injecté tout et n’importe quoi, il va falloir faire attention à quelles assemblies vous faites appellent et les capabilities de vos applications. Par exemple, pour inclure dynamiquement une pub PubCenter dans votre app, il va falloir que celle-ci contienne déjà une référence à la librairie PubCenter et que vous disposez de toutes les capabilities nécessaire à l’exécution de ce contrôle.

Sur son blog Julien propose une solution à un problème assez gênant : l’impossibilité de binder avec un MapItemsControl du toolkit. Pour parer à cela, Julien proposer une solution astucieuse avec un Behavior : classe !

Lire son article ici :

http://jlopresti.fr/post/2013/03/19/WP8-Binder-une-collection-sur-une-Map-!

Entre bretons, on aime se chamailler, on considère que cela nous fait progresser et il se trouve que pour Wikipedia WP8 (qui va bientôt arriver dès que je trouverais quelques heures) j’avais rencontré la même problématique et j’avais contourné cette problématique non pas un behavior mais une propriété d’extensions.

Ma solution

    public class MapTools : DependencyObject
    {
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Standard pattern.")]
        public static bool GetMapItemsSource(DependencyObject source)
        {
            return (bool)source.GetValue(MapItemsSourceProperty);
        }


        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Standard pattern.")]
        public static void SetMapItemsSource(DependencyObject source, IEnumerable value)
        {
            source.SetValue(MapItemsSourceProperty, value);
        }

        // Using a DependencyProperty as the backing store for MapItemsSource.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty MapItemsSourceProperty =
            DependencyProperty.Register("MapItemsSource", typeof(IEnumerable), typeof(Map), new PropertyMetadata(null, MapItemsSourceChanged));

        private static void MapItemsSourceChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var map = ((Map)sender);
            var itemsControl = MapExtensions.GetChildren(map).OfType<MapItemsControl>().FirstOrDefault();
            if (itemsControl != null)
            {
                itemsControl.ItemsSource = (IEnumerable)e.NewValue;
            }
        }
    }

et pour l’utiliser :

<maps:Map x:Name="Map" huynmap:MapTools.MapItemsSource="{Binding MyPlaces}" HorizontalAlignment="Stretch" ZoomLevel="15">
<toolkit:MapExtensions.Children>
<toolkit:MapItemsControl >
<toolkit:MapItemsControl.ItemTemplate>
<DataTemplate>
<toolkit:Pushpin .../>
</DataTemplate>
</toolkit:MapItemsControl.ItemTemplate>
</toolkit:MapItemsControl>
</toolkit:MapExtensions.Children>
</maps:Map>

Conclusion

Les deux solutions sont au final équivalente et utilisent les mêmes principes : se brancher au FrameworkElement Map, qui est le dernier élément à avoir accès au DataContext et gérer le MapItemsControl depuis ce point.

La différence est surtout que le Behavior est plus facilement exploitable sous Blend en WYSIWYG alors que la propriété d’extension elle à l’avantage de ne pas tirer des dépendances de librairies liées à Blend. On pourra toutefois espérer avec de meilleur performance au chargement pour la propriété d’extension (pas de dll à charger, moins complexe).

Merci Likeman

public class Datas
{

static Datas()
{
Instance = new Datas();
}
public static Datas Instance { get; set; }
}

Simple et efficace ! Enfin presque, car couplé à l’IsolatedStorageSettings cela peut mener à une catastrophe.

Voici un exemple de code :

public class Datas
{
static Datas()
{
if (IsolatedStorageSettings.ApplicationSettings.Contains("Data"))
{
Instance = IsolatedStorageSettings.ApplicationSettings["Data"] as Datas;
if (Instance != null)
return;
}
Instance = new Datas();

}

public void Save()
{
IsolatedStorageSettings.ApplicationSettings["Data"] = this;
IsolatedStorageSettings.ApplicationSettings.Save();
}

public String Login { get; set; }
public DateTime LastUpdate { get; set; }

[XmlIgnore]
public static Datas Instance { get; set; }
}

De toute évidence ce code fonctionne et est fiable, vous le trouverez assez souvent dans des tutoriaux par exemple.

Or ceci n’est qu’un apparence, prenez 2 minutes et essayez de trouver ce qu’il ne va pas dedans….

Un indice chez vous : Data.Instance peut retourner null dans certains cas.

Allez voilà ce qu’il va se passer !

Imaginons qu’avant d’utiliser la classe Datas, j’ai quelque part dans monde code :

IsolatedStorageSettings.ApplicationSettings.Contains(« UneAutreDonnee ») par exemple

L’isolatedStorageSettings va commencer par désérialiser l’ensemble de ses données, incluant ma donnée ["Data"]. Comme on le sait, le constructeur statique de Datas va être appelé à la première utilisation, donc dans notre cas si cela n’a pas été le cas avant : maintenant.

Or, le constructeur statique accède aussi à l’isolatedStorageSettings, qui est toujours en cours de désérialisation et là ça fait :

Pourquoi ?

Car comme c’est l’initialisateur de IsolatedSettings qui a appelé le constructeur statique, il a « hérité » des droits sur le lock de l’IsolatedSettings et donc a ainsi les droits une donnée qui est en train d’être créée !

« Operation not permitted on IsolatedStorageFileStream. »

Encore plus vicieux, l’initialisateur de l’IsolatedSettings a son propre try catch, donc aucune exception, mais qd vous allez faire  Data.Instance, celui ci vaudra NULL malgré toutes les sécurités que vous avez misent ! Or comme vous êtiez sûr que Data.Instance ne pouvait jamais valoir NULL, vous allez appeler par exemple : Data.Instance.Login et créer une belle exception qui fera planter votre application.

Pourquoi ca n’arrive pas quand on n’a jamais appelé IsolatedStorageSettings auparavant ?

Car comme on l’a dit, un constructeur statique n’est appelé qu’une seule fois, donc comme on vient de l’appeler via Data.Instance, l’IsolatedStorageSettings ne va pas le rappeler de nouveau, pas de problème de lock, pas d’exception.

Pourtant je suis sûr de ne pas appeler IsolatedStorageSettings avant ?

Moi aussi c’était ce que je pensais… mais en réalité il ne faut pas se contenter d’analyser que son propre code, il faut regarder ce que fait les librairies tierces par exemple. Or, Flurry par exemple stocke ses données dans l’isolatedStorageSettings aussi et comme il faut initialiser Flurry dès le chargement de l’application, il y a de grande chance qu’elle appelle l’IsolatedStorageSettings avant vous. Soyez donc toujours prévoyant !

La solution ?

Tout simplement externaliser la gestion du singleton en utilisant une seconde class que l’on va appeler « Provider », on sépare ainsi la gestion du singleton et la désérialisation.

public class DatasProvider
{
static DatasProvider()
{
if (IsolatedStorageSettings.ApplicationSettings.Contains("Data"))
{
Instance = IsolatedStorageSettings.ApplicationSettings["Data"] as Datas;
if (Instance != null)
return;
}
Instance = new Datas() { HasBeenCreated = true };

}

[XmlIgnore]
public static Datas Instance { get; set; }

}

public class Datas
{

public void Save()
{
IsolatedStorageSettings.ApplicationSettings["Data"] = this;
IsolatedStorageSettings.ApplicationSettings.Save();
}

public String Login { get; set; }

[XmlIgnore]
public bool HasBeenCreated { get; set; }
}

Le code Windows Phone 7 fonctionne t’il toujours ?

Non, sinon cet article aurait très peu d’intérêt évidemment.

Pourquoi ?

Car les brushs ont changé entre temps, certaines ont été ajoutées et surtout certaines ont été supprimées et c’est là que ça nous pose problème car le code Windows Phone 7 fait littéralement planter l’application.

Car en effet, depuis Mango, on ne peut plus redéfinir les brush, on avait donc pris la liberté de ne pas écraser les brushs mais de modifier directement leurs couleurs. Sauf que si la brush n’existe plus, le code suivant plante :

((SolidColorBrush)Resources["MaBrushQuiNExistePlus"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);

Car Resources["MaBrushQuiNExistePlus"] retourne null et comme on essaie d’accéder à sa propriété Color, on se retrouve avec une NullException.

Et c’est le cas de PhoneRadioCheckBoxBrush par exemple, qui a simplement disparu sous le runtime WP8

Mais les applications Windows Phone 7 qui tourne sous un Windows Phone 8 ?

Elle fonctionne très bien, le problème ne concerne que les application Windows Phone 8 !

Alors la solution ?

Reprendre l’ensemble des brush WP8 et les modifier de nouveau.

Commençons par le thème foncé :

private void DarkTheme()
{
((SolidColorBrush)Resources["PhoneRadioCheckBoxCheckBrush"]).Color = ((SolidColorBrush)Resources["PhoneRadioCheckBoxBorderBrush"]).Color = ((SolidColorBrush)Resources["PhoneForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneContrastForegroundBrush"]).Color = Color.FromArgb(0xFF, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneContrastBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneDisabledBrush"]).Color = Color.FromArgb(0x66, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneProgressBarBackgroundBrush"]).Color = Color.FromArgb(0x19, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextCaretBrush"]).Color = Color.FromArgb(0xFF, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxBrush"]).Color = Color.FromArgb(0xBF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextBoxForegroundBrush"]).Color = Color.FromArgb(0xFF, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxEditBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextBoxReadOnlyBrush"]).Color = Color.FromArgb(0x77, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneSubtleBrush"]).Color = Color.FromArgb(0x99, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextBoxSelectionForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneButtonBasePressedForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextHighContrastBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextMidContrastBrush"]).Color = Color.FromArgb(0x99, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextLowContrastBrush"]).Color = Color.FromArgb(0x73, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneSemitransparentBrush"]).Color = Color.FromArgb(0xAA, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneChromeBrush"]).Color = Color.FromArgb(0xFF, 0x1F, 0x1F, 0x1F);

((SolidColorBrush)Resources["PhoneInactiveBrush"]).Color = Color.FromArgb(0x33, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneInverseInactiveBrush"]).Color = Color.FromArgb(0xFF, 0xCC, 0xCC, 0xCC);
((SolidColorBrush)Resources["PhoneInverseBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneBorderBrush"]).Color = Color.FromArgb(0xBF, 0xFF, 0xFF, 0xFF);

}

et le thème clair :

private void DarkTheme()
{
((SolidColorBrush)Resources["PhoneRadioCheckBoxCheckBrush"]).Color = ((SolidColorBrush)Resources["PhoneRadioCheckBoxBorderBrush"]).Color = ((SolidColorBrush)Resources["PhoneForegroundBrush"]).Color = Color.FromArgb(0xDE, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneContrastForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneContrastBackgroundBrush"]).Color = Color.FromArgb(0xDE, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneDisabledBrush"]).Color = Color.FromArgb(0x4D, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneProgressBarBackgroundBrush"]).Color = Color.FromArgb(0x19, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextCaretBrush"]).Color = Color.FromArgb(0xDE, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxBrush"]).Color = Color.FromArgb(0x26, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxForegroundBrush"]).Color = Color.FromArgb(0xDE, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxEditBackgroundBrush"]).Color = Color.FromArgb(0x00, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxReadOnlyBrush"]).Color = Color.FromArgb(0x2E, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneSubtleBrush"]).Color = Color.FromArgb(0x66, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextBoxSelectionForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneButtonBasePressedForegroundBrush"]).Color = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneTextHighContrastBrush"]).Color = Color.FromArgb(0xDE, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextMidContrastBrush"]).Color = Color.FromArgb(0x73, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneTextLowContrastBrush"]).Color = Color.FromArgb(0x40, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneSemitransparentBrush"]).Color = Color.FromArgb(0xAA, 0xFF, 0xFF, 0xFF);
((SolidColorBrush)Resources["PhoneChromeBrush"]).Color = Color.FromArgb(0xFF, 0xDD, 0xDD, 0xDD);

((SolidColorBrush)Resources["PhoneInactiveBrush"]).Color = Color.FromArgb(0x33, 0x00, 0x00, 0x00);
((SolidColorBrush)Resources["PhoneInverseInactiveBrush"]).Color = Color.FromArgb(0xFF, 0xE5, 0xE5, 0xE5);
((SolidColorBrush)Resources["PhoneInverseBackgroundBrush"]).Color = Color.FromArgb(0xFF, 0xDD, 0xDD, 0xDD);
((SolidColorBrush)Resources["PhoneBorderBrush"]).Color = Color.FromArgb(0x99, 0x00, 0x00, 0x00);

}

et il suffira d’utiliser le code suivant dans le constructeur de App

if ((Visibility) Resources["PhoneLightThemeVisibility"] == Visibility.Visible)
{
DarkTheme();
}

Attention, comme sous Windows Phone 7, attention à forcer aussi le fond de vos pages

Plutôt gênant !!

Pourquoi cela ?

En fait, le bug n’intervenait que lorsque j’avais une tuile sur l’écran d’accueil. Après investigation, il se trouve que cela provient de la fonction WriteableBitmap.Render qui, s’il est appelé après Application_Desactivated, empêche tout retour à l’application.

Reproduire le problème

Il est assez facile de reproduire ce soucis :

• Créez une application windows phone 8
• Ajoutez le code suivant dans Application_Desactivated

WriteableBitmap wb = new WriteableBitmap(336, 336);
BitmapImage image = new BitmapImage(new Uri("/Assets/AlignmentGrid.png", UriKind.Relative));
var im = new Image() { Source = image, Height = 336, Width = 336 };
wb.Render(im, null);

• Lancez l’application
• Appuyez sur le bouton windows
• Appuyez sur le bouton « back »

L’explication

Comme beaucoup d’applications, je génère mes tuiles dynamiques en local en utilisant un  WriteableBitmap et j’appelle ma fonction de génération de tuiles dans Application_Desactivated et Application_Closing, deux évènements qui sont lancés lorsque l’on quitte l’application soit via le bouton Windows (ou un launcher), soit en fermant complètement l’application via le bouton « back ».

Tout ceci fonctionnait bien avec les applications Windows Phone 7, mais ce n’est plus le cas avec les applications Windows Phone 8 (précision : une application Windows Phone 7 tournant sur un Windows Phone 8 ne rencontre pas ce soucis).

Chose intéressante, l’image est bien généré ! C’est juste le retour à l’application qui est impossible, comme si WriteableBitmap.Render maintenait le thread UI et empêchait son retour.

Comment contourner ?

Pour contourner ce soucis, il faut se brancher un peu avant le Application_Desactivated comme par exemple sur l’évènement OnNavigatingFrom de chaque page. Cette solution pourrait fonctionner mais serait difficile à maintenir et assez contraignante.

On va donc se brancher encore un peu plus haut, au niveau de l’ApplicationFrame, pour cela dans App.xaml.cs

Ajoutez la ligne suivante dans InitializePhoneApplication :

RootFrame.Navigating += RootFrame_Navigating;

Puis ajoutez la fonction suivante :

void RootFrame_Navigating(object sender, NavigatingCancelEventArgs e)
{
if(e.Uri.OriginalString=="app://external/")
{

//gestion de mes tuiles

}

}

Et voilà !!

Attention, votre code sera appelé à la fois pour la désactivation et la fermeture, il n’est malheureusement pas possible à ce niveau de différencier les deux. Toutefois, cela devrait avoir peu d’effet car en général, on met à jour ses tuiles dans ces deux évènements.

Bonnes fêtes !

Beats Audio, what’s that ?

Comme le montre l’article suivant :

http://www.engadget.com/2011/10/13/htc-sensation-xe-with-beats-audio-review/

Beats audio est donc equalizer légèrement dynamique comprenant augmentation des basses et de la voix + une augmentation du volume général (malin !)

Encore plus malin, le téléphone détectera le casque que vous utilisez et n’utilisera les meilleurs profils que pour les casques de la marque Beats alors qu’un profil plus générique sera utilisé pour les autres casques.

A quoi cela ressemble sous Windows Phone ?

Prenons un 8X et allons voir à quoi ressemble les paramètres du son :

On ne peut faire plus simple comme configuration : On/Off et c’est tout ! Aucune possibilité de configurer votre equalizer selon vos préférences, rien.

Et les téléphones Nokia ?

Les téléphones nokia dispose d’un paramétrage nommé : « audio », si on entre dedans, voici ce que l’on a :

Un vrai equalizer avec une vingtaine de profils : amplification des basses, classique, dance, Jazz, Voix, etc…

Avec la possibilité de modifier manuellement les paramètres :

Mais c’est pas tout !

Les nokia prennent aussi en compte le son Dolby, l’idée est de « simuler » l’expérience 5.1 avec un casque 2.0, plus d’information ici :

http://membres.multimania.fr/homecine/surround/headphone.html

Au même titre que Beats Audio, on est là aussi dans du marketing avec un equalizer dynamique avec un son un peu plus aérien.

Conclusion

Toutefois Beats Audio est purement marketing, tout comme Dolby Headphone, il est difficile de voir dans cette technologie un avantage face aux Nokia qui proposent pour leurs parts à la fois une expérience Dolby Headphone et un equalizer manuel.

Avantage aux Nokia donc pour l’aspect audio.