Xamarin.Forms Classe d’appareil

Article
07/13/2023

La Device classe contient un certain nombre de propriétés et de méthodes pour aider les développeurs à personnaliser la disposition et les fonctionnalités par plateforme.

En plus des méthodes et des propriétés permettant de cibler le code à des types et tailles de matériel spécifiques, la Device classe inclut des méthodes qui peuvent être utilisées pour interagir avec les contrôles d’interface utilisateur à partir de threads d’arrière-plan. Pour plus d’informations, consultez Interagir avec l’interface utilisateur à partir de threads d’arrière-plan.

Fournir des valeurs spécifiques à la plateforme

Xamarin.Forms Avant la version 2.3.4, la plateforme sur laquelle l’application s’exécutait pouvait être obtenue en examinant la Device.OS propriété et en la TargetPlatform.iOScomparant aux valeurs d’énumération , TargetPlatform.Android, TargetPlatform.WinPhoneet TargetPlatform.Windows . De même, l’une des Device.OnPlatform surcharges peut être utilisée pour fournir des valeurs spécifiques à la plateforme à un contrôle.

Toutefois, depuis Xamarin.Forms la version 2.3.4, ces API ont été dépréciées et remplacées. La Device classe contient désormais des constantes de chaîne publiques qui identifient les plateformes : Device.iOS, Device.AndroidDevice.WinPhone(déprécié), Device.WinRT (déconseillé), Device.UWP, et Device.macOS. De même, les Device.OnPlatform surcharges ont été remplacées par les OnPlatform API et On .

En C#, vous pouvez fournir des valeurs spécifiques à la plateforme en créant une switch instruction sur la Device.RuntimePlatform propriété, puis en fournissant des case instructions pour les plateformes requises :

double top;
switch (Device.RuntimePlatform)
{
  case Device.iOS:
    top = 20;
    break;
  case Device.Android:
  case Device.UWP:
  default:
    top = 0;
    break;
}
layout.Margin = new Thickness(5, top, 5, 0);

Les OnPlatform classes et On fournissent les mêmes fonctionnalités en XAML :

<StackLayout>
  <StackLayout.Margin>
    <OnPlatform x:TypeArguments="Thickness">
      <On Platform="iOS" Value="0,20,0,0" />
      <On Platform="Android, UWP" Value="0,0,0,0" />
    </OnPlatform>
  </StackLayout.Margin>
  ...
</StackLayout>

La OnPlatform classe est une classe générique qui doit être instanciée avec un x:TypeArguments attribut qui correspond au type cible. Dans la On classe, l’attribut Platform peut accepter une seule string valeur ou plusieurs valeurs délimitées par des virgules string .

Important

La fourniture d’une valeur d’attribut incorrecte Platform dans la On classe n’entraîne pas d’erreur. Au lieu de cela, le code s’exécute sans que la valeur spécifique à la plateforme soit appliquée.

Vous pouvez également utiliser l’extension de OnPlatform balisage en XAML pour personnaliser l’apparence de l’interface utilisateur par plateforme. Pour plus d’informations, consultez Extension de balisage OnPlatform.

Device.Idiom

La Device.Idiom propriété peut être utilisée pour modifier des dispositions ou des fonctionnalités en fonction de l’appareil sur lequel l’application s’exécute. L’énumération TargetIdiom contient les valeurs suivantes :

Téléphone : iPhone, iPod touch et appareils Android inférieurs à 600 dips^
Tablette : iPad, appareils Windows et Appareils Android de plus de 600 dips^
Bureau : retourné uniquement dans les applications UWP sur Windows 10 ordinateurs de bureau (retourne Phone sur les appareils Windows mobiles, y compris dans les scénarios Continuum)
TV – Appareils Tizen TV
Regarder – Appareils tizen watch
Non pris en charge : inutilisé

^ dips n’est pas nécessairement le nombre de pixels physiques

La Idiom propriété est particulièrement utile pour créer des dispositions qui tirent parti des écrans plus grands, comme suit :

if (Device.Idiom == TargetIdiom.Phone) {
    // layout views vertically
} else {
    // layout views horizontally for a larger display (tablet or desktop)
}

La OnIdiom classe fournit les mêmes fonctionnalités en XAML :

<StackLayout>
    <StackLayout.Margin>
        <OnIdiom x:TypeArguments="Thickness">
            <OnIdiom.Phone>0,20,0,0</OnIdiom.Phone>
            <OnIdiom.Tablet>0,40,0,0</OnIdiom.Tablet>
            <OnIdiom.Desktop>0,60,0,0</OnIdiom.Desktop>
        </OnIdiom>
    </StackLayout.Margin>
    ...
</StackLayout>

La OnIdiom classe est une classe générique qui doit être instanciée avec un x:TypeArguments attribut qui correspond au type cible.

Vous pouvez également utiliser l’extension de OnIdiom balisage en XAML pour personnaliser l’apparence de l’interface utilisateur en fonction de l’idiome de l’appareil sur lequel l’application s’exécute. Pour plus d’informations, consultez Extension de balisage OnIdiom.

Device.FlowDirection

La Device.FlowDirection valeur récupère une valeur d’énumération FlowDirection qui représente le sens de flux actuel utilisé par l’appareil. La direction de flux est la direction dans laquelle les éléments d’IU sur la page sont analysés par l’œil. Ces valeurs sont les suivantes :

En XAML, la valeur peut être récupérée à l’aide Device.FlowDirection de l’extension de x:Static balisage :

<ContentPage ... FlowDirection="{x:Static Device.FlowDirection}"> />

Le code équivalent en C# est :

this.FlowDirection = Device.FlowDirection;

Pour plus d’informations sur la direction du flux, consultez Localisation de droite à gauche.

Device.Styles

La Styles propriété contient des définitions de style intégrées qui peuvent être appliquées à la propriété de certains contrôles (comme Label) Style . Les styles disponibles sont les suivants :

Bodystyle
CaptionStyle
ListItemDetailTextStyle
ListItemTextStyle
SubtitleStyle
Titlestyle

Device.GetNamedSize

GetNamedSize peut être utilisé lors de la définition FontSize dans le code C# :

myLabel.FontSize = Device.GetNamedSize (NamedSize.Small, myLabel);
someLabel.FontSize = Device.OnPlatform (
      24,         // hardcoded size
      Device.GetNamedSize (NamedSize.Medium, someLabel),
      Device.GetNamedSize (NamedSize.Large, someLabel)
);

Device.GetNamedColor

Xamarin.Forms 4.6 introduit la prise en charge des couleurs nommées. Une couleur nommée est une couleur qui a une valeur différente selon le mode système (par exemple, clair ou foncé) actif sur l’appareil. Sur Android, les couleurs nommées sont accessibles via la classe R.Color . Sur iOS, les couleurs nommées sont appelées couleurs système. Sur le plateforme Windows universelle, les couleurs nommées sont appelées ressources de thème XAML.

La GetNamedColor méthode peut être utilisée pour récupérer des couleurs nommées sur Android, iOS et UWP. La méthode prend un string argument et retourne un Color:

// Retrieve an Android named color
Color color = Device.GetNamedColor(NamedPlatformColor.HoloBlueBright);

Color.Default est retourné lorsqu’un nom de couleur est introuvable ou lorsqu’il GetNamedColor est appelé sur une plateforme non prise en charge.

Notes

Étant donné que la GetNamedColor méthode retourne un Color qui est spécifique à une plateforme, elle doit généralement être utilisée conjointement avec la Device.RuntimePlatform propriété .

La NamedPlatformColor classe contient les constantes qui définissent les couleurs nommées pour Android, iOS et UWP :

Android	iOS	macOS	UWP
`BackgroundDark`	`Label`	`AlternateSelectedControlTextColor`	`SystemAltHighColor`
`BackgroundLight`	`Link`	`ControlAccent`	`SystemAltLowColor`
`Black`	`OpaqueSeparator`	`ControlBackgroundColor`	`SystemAltMediumColor`
`DarkerGray`	`PlaceholderText`	`ControlColor`	`SystemAltMediumHighColor`
`HoloBlueBright`	`QuaternaryLabel`	`DisabledControlTextColor`	`SystemAltMediumLowColor`
`HoloBlueDark`	`SecondaryLabel`	`FindHighlightColor`	`SystemBaseHighColor`
`HoloBlueLight`	`Separator`	`GridColor`	`SystemBaseLowColor`
`HoloGreenDark`	`SystemBlue`	`HeaderTextColor`	`SystemBaseMediumColor`
`HoloGreenLight`	`SystemGray`	`HighlightColor`	`SystemBaseMediumHighColor`
`HoloOrangeDark`	`SystemGray2`	`KeyboardFocusIndicatorColor`	`SystemBaseMediumLowColor`
`HoloOrangeLight`	`SystemGray3`	`Label`	`SystemChromeAltLowColor`
`HoloPurple`	`SystemGray4`	`LabelColor`	`SystemChromeBlackHighColor`
`HoloRedDark`	`SystemGray5`	`Link`	`SystemChromeBlackLowColor`
`HoloRedLight`	`SystemGray6`	`LinkColor`	`SystemChromeBlackMediumColor`
`TabIndicatorText`	`SystemGreen`	`PlaceholderText`	`SystemChromeBlackMediumLowColor`
`Transparent`	`SystemIndigo`	`PlaceholderTextColor`	`SystemChromeDisabledHighColor`
`White`	`SystemOrange`	`QuaternaryLabel`	`SystemChromeDisabledLowColor`
`WidgetEditTextDark`	`SystemPink`	`QuaternaryLabelColor`	`SystemChromeHighColor`
	`SystemPurple`	`SecondaryLabel`	`SystemChromeLowColor`
	`SystemRed`	`SecondaryLabelColor`	`SystemChromeMediumColor`
	`SystemTeal`	`SelectedContentBackgroundColor`	`SystemChromeMediumLowColor`
	`SystemYellow`	`SelectedControlColor`	`SystemChromeWhiteColor`
	`TertiaryLabel`	`SelectedControlTextColor`	`SystemListLowColor`
		`SelectedMenuItemTextColor`	`SystemListMediumColor`
		`SelectedTextBackgroundColor`
		`SelectedTextColor`
		`Separator`
		`SeparatorColor`
		`ShadowColor`
		`SystemBlue`
		`SystemGray`
		`SystemGreen`
		`SystemIndigo`
		`SystemOrange`
		`SystemPink`
		`SystemPurple`
		`SystemRed`
		`SystemTeal`
		`SystemYellow`
		`TertiaryLabel`
		`TertiaryLabelColor`
		`TextBackgroundColor`
		`TextColor`
		`UnderPageBackgroundColor`
		`UnemphasizedSelectedContentBackgroundColor`
		`UnemphasizedSelectedTextBackgroundColor`
		`UnemphasizedSelectedTextColor`
		`WindowBackgroundColor`
		`WindowFrameTextColor`

Device.StartTimer

La Device classe dispose également d’une StartTimer méthode qui fournit un moyen simple de déclencher des tâches dépendantes du temps qui fonctionnent dans Xamarin.Forms du code commun, y compris une bibliothèque .NET Standard. Passez un TimeSpan pour définir l’intervalle et revenir true pour maintenir le minuteur en cours d’exécution ou false pour l’arrêter après l’appel actuel.

Device.StartTimer (new TimeSpan (0, 0, 60), () =>
{
    // do something every 60 seconds
    return true; // runs again, or false to stop
});

Si le code à l’intérieur du minuteur interagit avec l’interface utilisateur (par exemple, la définition du texte d’un Label ou l’affichage d’une alerte), il doit être effectué à l’intérieur d’une BeginInvokeOnMainThread expression (voir ci-dessous).

Notes

Les System.Timers.Timer classes et System.Threading.Timer sont des alternatives .NET Standard à l’utilisation de la Device.StartTimer méthode .

Interagir avec l’interface utilisateur à partir de threads d’arrière-plan

La plupart des systèmes d’exploitation, y compris iOS, Android et le plateforme Windows universelle, utilisent un modèle de thread unique pour le code impliquant l’interface utilisateur. Ce thread est souvent appelé thread main ou thread d’interface utilisateur. Une conséquence de ce modèle est que tout le code qui accède aux éléments d’interface utilisateur doit s’exécuter sur le thread main de l’application.

Les applications utilisent parfois des threads d’arrière-plan pour effectuer des opérations potentiellement longues, telles que la récupération de données à partir d’un service web. Si le code s’exécutant sur un thread en arrière-plan doit accéder aux éléments d’interface utilisateur, il doit exécuter ce code sur le thread main.

La Device classe inclut les méthodes suivantes static qui peuvent être utilisées pour interagir avec des éléments d’interface utilisateur à partir de threads d’arrière-plan :

Méthode	Arguments	Retours	Objectif
`BeginInvokeOnMainThread`	`Action`	`void`	Appelle un `Action` sur le thread main et n’attend pas qu’il se termine.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	Appelle un `Func<T>` sur le thread principal, puis attend qu’il se termine.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Appelle un `Action` sur le thread principal, puis attend qu’il se termine.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	Appelle un `Func<Task<T>>` sur le thread principal, puis attend qu’il se termine.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	Appelle un `Func<Task>` sur le thread principal, puis attend qu’il se termine.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	Retourne le `SynchronizationContext` pour le thread principal.

Le code suivant montre un exemple d’utilisation de la BeginInvokeOnMainThread méthode :

Device.BeginInvokeOnMainThread (() =>
{
    // interact with UI elements
});