Comment obtenir/détecter la taille de l'écran dans Xamarin.Forms?
J'essaie de réécrire une application que j'ai écrite pour iOS. J'allais écrire une version Android mais pensais qu'il valait mieux en profiter pour utiliser Xamarin.Forms. En le faisant une page à la fois, je suis maintenant bloqué sur une page où je dois obtenir la largeur et la hauteur de l'écran. Est-ce que quelqu'un connaît l'équivalent d'iOS 'View.Frame.Width dans Xamarin.Forms?
Il n’existe actuellement aucun moyen de Xamarin.Forms lui-même, mais nous l’avons implémentée en tant qu’interface compatible PCL dans Xamarin.Forms.Labs que vous pouvez obtenir à partir de NuGet ou le code source de GitHub.
https://github.com/XForms/Xamarin-Forms-Labs
IDevice a la propriété IDisplay avec les informations; hauteur, largeur, densité de pixels pour X & Y et quelques méthodes d’extension pour calculer la taille en pouces.
Exemple de page pour obtenir des informations de l'appareil:
#region Display information
var display = device.Display;
var displayFrame = new Frame();
if (display != null)
{
displayFrame.Content = new StackLayout()
{
Children =
{
new Label() { Text = display.ToString() },
new Label() { Text = string.Format("Screen width is\t {0:0.0} inches.", display.ScreenWidthInches()) },
new Label() { Text = string.Format("Screen height is\t {0:0.0} inches.", display.ScreenHeightInches()) },
new Label() { Text = string.Format("Screen diagonal size is\t {0:0.0} inches.", display.ScreenSizeInches()) }
}
};
}
else
{
displayFrame.Content = new Label() { TextColor = Color.Red, Text = "Device does not contain display information." };
}
stack.Children.Add(displayFrame);
#endregion
Création d'un cadre exact pouce par pouce sur toutes les plateformes, quelles que soient les propriétés d'affichage:
public class AbsoluteLayoutWithDisplayInfoPage : ContentPage
{
public AbsoluteLayoutWithDisplayInfoPage(IDisplay display)
{
this.Title = "Absolute Layout With Display Info";
var abs = new AbsoluteLayout();
var inchX = display.WidthRequestInInches(1);
var inchY = display.HeightRequestInInches(1);
var originX = display.WidthRequestInInches(display.ScreenWidthInches() / 2);
var originY = display.HeightRequestInInches(display.ScreenHeightInches() / 2);
abs.Children.Add(new Label() { Text = "1\"x\"1\" blue frame" });
abs.Children.Add(new Frame()
{
BackgroundColor = Color.Navy,
},
new Rectangle(originX - inchX/2, originY - inchY/2, inchX, inchY));
abs.Children.Add(new Frame()
{
BackgroundColor = Color.White
},
new Rectangle(originX - inchX/16, originY - inchY/16, inchX/8, inchY/8));
this.Content = abs;
}
}
Pour obtenir les informations sur le périphérique, définissez votre résolveur DI ou utilisez un conteneur statique. Les trois plates-formes ont des appels de périphérique singleton avec la propriété statique CurrentDevice:
resolverContainer.Register<IDevice>(t => WindowsPhoneDevice.CurrentDevice)
resolverContainer.Register<IDevice>(t => AppleDevice.CurrentDevice)
resolverContainer.Register<IDevice>(t => AndroidDevice.CurrentDevice)
Il existe un moyen simple d'obtenir la largeur et la hauteur de l'écran en Xamarin.Forms et d'y accéder de manière globale depuis n'importe où dans votre application. Je ferais quelque chose comme ça:
1. Créez deux membres publics dans votre App.cs:
public static class App
{
public static int ScreenWidth;
public static int ScreenHeight;
...
}
2. Définissez les valeurs dans votre MainActivity.cs (Android) ou votre AppDelegate.cs (iOS):
Android:
protected override void OnCreate(Bundle bundle)
{
...
App.ScreenWidth = (int)Resources.DisplayMetrics.WidthPixels; // real pixels
App.ScreenHeight = (int)Resources.DisplayMetrics.HeightPixels; // real pixels
// App.ScreenWidth = (int)(Resources.DisplayMetrics.WidthPixels / Resources.DisplayMetrics.Density); // device independent pixels
// App.ScreenHeight = (int)(Resources.DisplayMetrics.HeightPixels / Resources.DisplayMetrics.Density); // device independent pixels
...
}
iOS:
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
...
App.ScreenWidth = (int)UIScreen.MainScreen.Bounds.Width;
App.ScreenHeight = (int)UIScreen.MainScreen.Bounds.Height;
...
}
Si vous utilisez des formulaires xamarin, vous pouvez trouver la largeur et la hauteur de l’écran actuel dans la bibliothèque de classes portable (pcl) comme ci-dessous.
Pour la largeur, vous utilisez ceci dans pcl,
Application.Current.MainPage.Width
Pour la hauteur, vous pouvez le faire en pcl,
Application.Current.MainPage.Height
Recette
Créez une nouvelle application Xamarin.Android nommée ScreenSize . Modifiez Main.axml afin qu'elle contienne deux TextViews:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:orientation="vertical"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent">
<TextView
Android:text="Screen Width:"
Android:textAppearance="?android:attr/textAppearanceLarge"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:id="@+id/screenWidthDp" />
<TextView
Android:text="Screen Height:"
Android:textAppearance="?android:attr/textAppearanceLarge"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:id="@+id/screenHeightDp" />
</LinearLayout>
Modifiez Activity1.cs, modifiez le code dans OnCreate comme suit:
! [Entrez la description de l'image ici] [1] private int ConvertPixelsToDp (float pixelValue) { var dp = (int) ((pixelValue) /Resources.DisplayMetrics.Density); renvoyer dp; }
Lancer l'application. Selon l'appareil, il affichera la hauteur et la largeur de l'écran. La capture d'écran suivante provient d'un Galaxy Nexus:
[lien de l'image] http://i.stack.imgur.com/TQhba.png
Dans votre fichier App, définissez une variable statique publique.
public static Size ScreenSize;
Vous devez initialiser la variable dans IOS et Android avant d'appeler le constructeur de l'application. Pour IOS, dans la méthode FinishedLaunching
App.ScreenSize = new Size(UIScreen.MainScreen.Bounds.Width, UIScreen.MainScreen.Bounds.Height);
et pour Android, dans la fonction OnCreate
App.ScreenSize = new Xamarin.Forms.Size((int)(Resources.DisplayMetrics.WidthPixels / Resources.DisplayMetrics.Density), (int)(Resources.DisplayMetrics.HeightPixels / Resources.DisplayMetrics.Density));
Mise à jour pour les futurs développeurs qui tentent de faire cela qui ne l’a pas regardé ou qui l’a ratée. La classe Page hérite de VisualElement, qui possède maintenant deux propriétés (pouvant être liées pour être utilisées dans XAML):
Width - Obtient la largeur de rendu actuelle de cet élément. Ceci est une propriété pouvant être reliée en lecture . Height - Obtient la hauteur de rendu actuelle de cet élément. Il s'agit d'une propriété pouvant être liée en lecture seule.
dans votre page codeehind vous feriez juste quelque chose comme:
var myWidth = this.Width;
var myHeight = this.Height;
si vous souhaitez savoir si cela change, utilisez l'événement SizeChanged:
public MyPage()
{
SizeChanged += OnSizeChanged;
}
private void OnSizeChanged(object sender, EventArgs e)
{
var myWidth = this.Width;
var myHeight = this.Height;
}