Localisation d'une application Windows Phone 8

Les tendances récentes des magasins montrent que proposer votre application en anglais ne couvrira qu'environ 25% des clients Windows Phone. L'ajout d'espagnol, de français, de mandarin, de russe et d'allemand peut augmenter la couverture de plus de 75% des clients Windows Phone..

introduction

Dans ce didacticiel, je vais vous apprendre à localiser une application Windows Phone 8 pour atteindre davantage de clients potentiels. Je vais vous montrer comment configurer votre projet Windows Phone 8 afin que toute l'interface utilisateur, y compris les messages d'erreur, puisse être localisée. À la fin du didacticiel, vous aurez appris comment préparer votre application de sorte qu'elle puisse être traduite dans plusieurs langues..

Considérez les meilleures pratiques suivantes pour créer une application facile à localiser:

Créez des fichiers de ressources distincts pour les chaînes, les images et les vidéos afin de rendre votre langage de code indépendant. Cela garantit qu'il peut prendre en charge différentes langues.
Activer la prise en charge multiligne et les contrôles d’intégration du texte. Cela vous donne plus d'espace pour afficher des chaînes.
Localisez des phrases plutôt que des mots. Cela peut sembler un travail supplémentaire, mais c'est la meilleure solution. Cela garantira, par exemple, que les messages d'erreur sont correctement traduits dans toutes les langues.
Ne présumez pas que chaque langue utilise des paramètres dans le même ordre.
Ne réutilisez pas de chaînes, car cela peut entraîner des problèmes de localisation si le contexte de la chaîne change. Par exemple, une chaîne telle que "text" et "fax" pourrait être utilisée à la fois comme verbe et nom en anglais, ce qui peut compliquer le processus de traduction. Créer une chaîne séparée pour chaque contexte.
Utilisez des attributs uniques pour identifier vos ressources. Vous pouvez accéder à une ressource uniquement en utilisant sa valeur unique, qui ne change pas, plutôt qu'en utilisant la valeur réelle de la ressource..

Nous allons d'abord discuter de la prise en charge culturelle et linguistique de Windows Phone 8, puis des étapes nécessaires à la préparation d'une application pour la localisation. Après cela, nous verrons comment construire une barre d’application localisée. Nous allons enfin discuter de la façon de tester une application localisée.

1. Soutien culturel et linguistique

Les chiffres, les devises, la date et l'heure sont formatés différemment selon les cultures. Toutes les cultures prises en charge sont répertoriées dans le CultureInfo classe. le CultureInfo La classe expose les propriétés à accéder aux données de format de région pour une culture spécifique. Vous pouvez également utiliser le CultureInfo classe avec un code de culture pour accéder aux règles de formatage et de tri intégrées pour cette culture.

La langue d'affichage détermine la police d'interface utilisateur par défaut. L'interface utilisateur de Windows Phone 8.1 est localisée dans 50 langues, mais votre application peut afficher une plus grande sélection de langues. Lorsque vous ajoutez un support à votre application pour des langues supplémentaires, Visual Studio génère un .resx fichier pour chaque langue.

le InitializeLanguage fonctionner dans le App.xaml.cs fichier définit l'application RootFrame.Language basé sur la valeur de la AppResources.ResourceLanguage Ressource.

2. Etapes de localisation standard

Nouveaux projets et modèles pour Windows Phone 8 Les applications XAML fournissent plusieurs nouvelles fonctionnalités utiles:

Un fichier de ressource de langue neutre, AppResources.resx, est ajouté par défaut à chaque nouveau projet.
le LocalizedStrings La classe d'assistance est déjà configurée pour fournir un accès facile aux ressources qui correspondent à la culture actuelle d'une application..
Un nouveau fichier de ressources avec le nom spécifique à l'environnement local et les paramètres d'initialisation de la langue de l'application en place est créé lors de l'ajout d'un Culture soutenue du Propriétés du projet dans Visual Studio.

Voyons comment tout cela fonctionne en créant un exemple d'application, avec l'anglais comme langue de base..

Étape 1: Liaison des éléments de texte XAML

Nous lions d’abord les éléments de texte XAML aux ressources de chaîne.

Copiez chaque chaîne codée en dur dans le XAML de l'application qui doit être localisée sur une nouvelle ligne de la table des chaînes de votre AppResources.resx fichier.

Ensuite, référez les éléments XAML à cette ressource chaîne en ajoutant le nom unique et une clause de liaison standard à la place de la valeur codée en dur.

le TextBlock ci-dessous est lié en utilisant la chaîne ressource à la place du texte codé en dur.

Recherchez dans le code-behind du projet les endroits où le code modifie un attribut de texte d'un élément d'interface utilisateur. Remplacer la valeur codée en dur par une référence à la ressource chaîne pour chaque élément.

ApplicationBarMenuItem about_appBarMenuItem = new ApplicationBarMenuItem (AppResources.AppBarAboutMenuItem);

Étape 2: Ajout de langues

L'ajout de langues à un projet Windows Phone 8 dans Visual Studio est simple. Accédez à la page de propriétés du projet et sélectionnez les langues que vous souhaitez prendre en charge dans la liste. Cultures soutenues liste.

Dans l'exemple de projet, j'ai ajouté Chinois simplifié) et Espagnol (Espagne), dont les codes de localisation sont Zh-Hans et es-ES, respectivement. Sélectionnez les langues que vous souhaitez que votre application prenne en charge dans Cultures soutenues case sur le projet Propriétés page.

Lorsque vous enregistrez le projet, Visual Studio crée un AppResources.resx fichier pour chaque locale. Le fichier de ressources nouvellement créé est pré-rempli avec les ressources existantes du répertoire principal. AppResources.resx fichier.

Chaque fichier de ressources comprend deux ressources spéciales nommées Langage de ressources et ResourceFlowDirection. Ces deux ressources sont utilisées lorsque le InitializeLanguage la méthode est appelée de la App.xaml.cs constructeur. Leurs valeurs sont vérifiées automatiquement pour s'assurer qu'elles correspondent à la culture du fichier de ressources chargé au moment de l'exécution..

le Langage de ressources la valeur est initialisée avec le nom de paramètres régionaux du fichier de ressources et est utilisée pour définir la RootFrame.Language valeur. le ResourceFlowDirection la valeur est définie sur la direction traditionnelle de la langue de la ressource.

Notez que Langage de ressources et ResourceFlowDirection peut être modifié pour s'aligner sur le style de conception de votre application.

Étape 3: Utilisation de la trousse à outils multilingues pour la traduction

le Boîte à outils pour applications multilingues (MAT), intégré à Visual Studio, prend en charge la traduction, la gestion des fichiers de traduction et des outils de localisation pour créer des applications Windows Phone et Windows Store. Voici quelques avantages de l’utilisation de la boîte à outils des applications multilingues:

Il centralise la gestion des ressources de chaînes et des métadonnées.
Cet outil facilite la création, l'importation et l'exportation de fichiers de traduction au format XLIFF, un standard de l'industrie..
Il n'est pas nécessaire de basculer entre les fichiers de ressources.
Il est facile d’ajouter de nouvelles langues traduites directement à partir du menu contextuel du projet..

Pour commencer à utiliser le Toolkit multilingue des applications pour votre projet Windows Phone, téléchargez et installez l'extension Visual Studio à partir de MSDN. Avec la boîte à outils installée, sélectionnez le projet et sélectionnez Activer la boîte à outils des applications multilingues du Outils menu comme ci-dessous.

Notez que les ressources localisées sont définies par projet et non par solution. Cela signifie que l'objectif de Visual Studio doit être au sein du projet pour la Activer la boîte à outils des applications multilingues possibilité d'être disponible à partir du Outils menu.

Après avoir activé le Toolkit multilingue des applications, Visual Studio ajoute des fichiers au Ressource dossier de votre projet, l'un d'entre eux ayant un nouveau type et nom, AppResources.qps.ploc.xlf. le .xlf extension fait référence au format de fichier standard XLIFF que j'ai mentionné précédemment.

Des langues supplémentaires peuvent être ajoutées via le Toolkit de l'application multilingue. Cela se traduit par l'ajout d'une nouvelle culture prise en charge à votre projet. Cela provoque également l’ajout d’une langue prise en charge dans le projet. WMAppManifest.xml.

Traduire les ressources pour Chinois simplifié) et Espagnol (Espagne), clic droit sur le .xlf déposer et sélectionner Générer des traductions automatiques dans le menu contextuel. Appliquez les traductions et reconstruisez le projet pour voir les modifications reflétées dans le .resx fichiers pour les deux langues supplémentaires.

3. Construction d'une barre d'application localisée

Vous pouvez ajouter une barre d'application à une page de votre application, soit dans la page XAML, soit en utilisant C # dans la page code-behind.. Barre d'application n'est pas un DependencyObject et ne supporte pas les fixations. Cela signifie que si vous avez besoin de le localiser, construisez le Barre d'application depuis code-behind C #.

Lorsqu'un nouveau projet Windows Phone 8 ou Windows Phone 8.1 Silverlight est créé, un code commenté pour la localisation de la barre d'application est ajouté. MainPage.xaml.cs par défaut. Ne commentez pas la méthode BuildLocalizedApplicationBar et ajoutez les boutons, les éléments de menu et les ressources associées que vous souhaitez utiliser dans votre application..

private void BuildLocalizedApplicationBar () // Définit le champ ApplicationBar de la page sur une nouvelle instance de ApplicationBar. ApplicationBar = new ApplicationBar (); // Crée un nouveau bouton et définit la valeur du texte sur la chaîne localisée à partir de AppResources. ApplicationBarIconButton appBarButton = new ApplicationBarIconButton (new Uri ("/ Assets / Check.png", UriKind.Relative)); appBarButton.Text = AppResources.AppBarButtonText; appBarButton.Click + = appBarButton_Click; ApplicationBar.Buttons.Add (appBarButton); // Crée un nouvel élément de menu avec la chaîne localisée à partir de AppResources. ApplicationBarMenuItem zh_appBarMenuItem = new ApplicationBarMenuItem ("中文"); ApplicationBar.MenuItems.Add (zh_appBarMenuItem); zh_appBarMenuItem.Click + = new EventHandler (zh_appBarMenuItem_Click); ApplicationBarMenuItem en_appBarMenuItem = new ApplicationBarMenuItem ("anglais"); ApplicationBar.MenuItems.Add (en_appBarMenuItem); en_appBarMenuItem.Click + = new EventHandler (en_appBarMenuItem_Click); ApplicationBarMenuItem es_appBarMenuItem = new ApplicationBarMenuItem ("español"); ApplicationBar.MenuItems.Add (es_appBarMenuItem); es_appBarMenuItem.Click + = new EventHandler (es_appBarMenuItem_Click);

le BuildLocalizedApplicationBar méthode crée une nouvelle instance de Barre d'application. Des boutons et des éléments de menu y sont ajoutés et la valeur du texte est définie sur la chaîne localisée de AppResources. Le bouton de la barre d’application a une obligation de AppBarButtonText, qui est défini dans le AppResouces.resx fichier. Appeler le BuildLocalizedApplicationBar méthode du constructeur de la page pour charger le Barre d'application.

Dans l’exemple d’application, les utilisateurs peuvent sélectionner leur langue d’affichage via le Barre d'application menu. Comme illustré dans la capture d'écran ci-dessous, les éléments de menu restent cohérents dans toutes les langues d'affichage, tandis que le bouton de la barre d'applications est localisé..

Lorsqu'un utilisateur appuie sur une langue d'affichage dans le Barre d'application menu, le SetUILanguage méthode est appelée. le SetUILanguage La méthode, avec le nom de la langue cible passé en paramètre, est utilisée pour définir la langue d'affichage.

private void SetUILanguage (chaîne locale) CultureInfo newCulture = new CultureInfo (locale); Thread.CurrentThread.CurrentCulture = newCulture; Thread.CurrentThread.CurrentUICulture = newCulture; FlowDirection flow = (FlowDirection) Enum.Parse (typeof (FlowDirection), AppResources.ResourceFlowDirection); App.RootFrame.FlowDirection = flow; // Définit la langue du RootFrame pour correspondre à la nouvelle culture. App.RootFrame.Language = XmlLanguage.GetLanguage (AppResources.ResourceLanguage);

le SetUILanguage La méthode réinitialise d'abord le CurrentUICulture de l'application aux paramètres régionaux fournis dans l'appel. Tout texte lié aux ressources rendu par l'application utilisera les ressources des paramètres régionaux spécifiés après cet appel..

Ensuite, réglez le Sens de l'écoulement et La langue du RootFrame, ce qui entraînera l'interface utilisateur rendue par l'application à suivre les nouveaux paramètres.

le BuildLocalizedApplicationBar La méthode est appelée à partir du constructeur de la page après l'appel de InitializeComponent localiser le Barre d'application.

public MainPage () InitializeComponent (); // code pour localiser le ApplicationBar BuildLocalizedApplicationBar ();

4. Tester une application localisée

L'émulateur Windows Phone peut être utilisé pour tester l'application localisée. Changez la langue d'affichage en langue que cible l'application pour vérifier que le contenu est restitué correctement.

Cliquez sur Lancer le débogage du Déboguer menu.
Aller vers région et langue de Réglages dans la liste des applications.
Cliquez sur Langue d'affichage et sélectionnez l'une des langues. Utilisez la table dans le Mappage de noms de culture sur des langues d'affichage section pour déterminer la chaîne de langue d'affichage à sélectionner.
Acceptez les modifications et redémarrez l'émulateur.
Lancez votre application en revenant à la liste des applications et vérifiez que la langue de chaque chaîne localisée correspond au paramètre de langue d'affichage sélectionné précédemment..

Voici comment le texte change lorsque la langue d'affichage est modifiée. Notez que les éléments de menu restent cohérents même si la langue d'affichage change.

Pour changer dynamiquement de langue, appelez le SetUILanguage méthode avec le nom de la langue cible passé en paramètre.

Dans l'exemple d'application, chaque élément d'interface utilisateur du MainPage.xaml a déjà été rendu, de sorte que les éléments affichés doivent être actualisés après le changement de langue. le updateUI méthode rafraîchit les éléments de l'interface utilisateur de MainPage.xaml.

void privé updateUI () apptitle.Text = AppResources.ApplicationTitle; pagetitle.Text = AppResources.mainpagetitle; usermessage.Text = AppResources.displayMessage; checkbutton.Content = AppResources.checkEligibility; enterage.Text = AppResources.userMessage;

Notez que l'emplacement de chaque élément de l'interface utilisateur à l'écran reste inchangé, quelle que soit la langue d'affichage..

Conclusion

Dans ce didacticiel, vous avez appris à préparer votre application pour la localisation. Les chaînes XAML codées en dur et code-behind qui doivent être localisées sont placées dans une table de chaînes de fichiers de ressources et reçoivent une clé unique..

Chaque valeur codée en dur est remplacée par une clause de liaison dans XAML ou une référence de ressource dans un code utilisant la clé pour la ressource chaîne associée..

Vous pouvez ajouter des langues d'affichage supplémentaires et utiliser Multilingual App Toolkit pour faciliter considérablement le processus de traduction de votre application de bout en bout. N'hésitez pas à télécharger les fichiers sources du didacticiel à utiliser comme référence.

Code