Xamarin.Forms Classe d’appareil

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 pour 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 comparant aux TargetPlatform.iOSvaleurs , TargetPlatform.Androidet TargetPlatform.WinPhoneTargetPlatform.Windows aux valeurs d’énumération. 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éconseillées et remplacées. La Device classe contient désormais des constantes de chaîne publique qui identifient les plateformes Device.iOS: , Device.AndroidDevice.WinPhone(déconseillé), (déconseillé), Device.WinRT (déconseillé), Device.UWPet Device.macOS. De même, les Device.OnPlatform surcharges ont été remplacées par les API et On les OnPlatform API.

En C#, les valeurs spécifiques à la plateforme peuvent être fournies 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 les classes 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 valeur unique string 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 balisage en XAML pour personnaliser l’apparence OnPlatform de l’interface utilisateur par plateforme. Pour plus d’informations, consultez l’extension de balisage OnPlatform.

Device.Idiom

La Device.Idiom propriété peut être utilisée pour modifier les dispositions ou les 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 plus étroits que 600 dips^
Tablette : iPad, appareils Windows et appareils Android plus larges que 600 dips^
Bureau : retourné uniquement dans les applications UWP sur les ordinateurs de bureau Windows 10 (retourne Phone sur les appareils Windows mobiles, y compris dans les scénarios Continuum)
TV – Appareils de télévision Tizen
Espion – Appareils de montre Tizen
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 OnIdiom de 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 l’extension de balisage OnIdiom.

Device.FlowDirection

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

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

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

Le code équivalent en C# est le suivant :

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 à certaines propriétés de contrôle (par Labelexemple). 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. Dans 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.

Remarque

Étant donné que la GetNamedColor méthode retourne une Color valeur 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 a également une StartTimer méthode qui fournit un moyen simple de déclencher des tâches dépendantes du temps qui fonctionnent dans Xamarin.Forms le code commun, y compris une bibliothèque .NET Standard. Passez un TimeSpan pour définir l’intervalle et revenir true pour conserver 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’une Label alerte ou l’affichage d’une alerte) il doit être effectué à l’intérieur d’une BeginInvokeOnMainThread expression (voir ci-dessous).

Remarque

Les System.Timers.Timer classes et System.Threading.Timer les classes 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 principal 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 principal 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 d’arrière-plan doit accéder aux éléments d’interface utilisateur, il doit exécuter ce code sur le thread principal.

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

Method	Arguments	Retours	Objectif
`BeginInvokeOnMainThread`	`Action`	`void`	Appelle un `Action` thread principal 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
});

API d’appareil

Last updated on 2020-07-20

Partage via