Xamarin.Forms Classe de dispositivo

Artigo
07/13/2023

A Device classe contém várias propriedades e métodos para ajudar os desenvolvedores a personalizar o layout e a funcionalidade por plataforma.

Além de métodos e propriedades para direcionar código em tipos e tamanhos de hardware específicos, a Device classe inclui métodos que podem ser usados para interagir com controles de interface do usuário de threads em segundo plano. Para obter mais informações, consulte Interagir com a interface do usuário de threads em segundo plano.

Fornecer valores específicos da plataforma

Antes da Xamarin.Forms 2.3.4, a plataforma em que o aplicativo estava em execução podia ser obtida examinando a propriedade e comparando-a Device.OS com os TargetPlatform.iOSvalores de enumeração , TargetPlatform.AndroidTargetPlatform.WinPhone, e TargetPlatform.Windows . Da mesma forma, uma das Device.OnPlatform sobrecargas pode ser usada para fornecer valores específicos da plataforma a um controle.

No entanto, desde Xamarin.Forms 2.3.4, essas APIs foram preteridas e substituídas. A Device classe agora contém constantes de cadeia de caracteres públicas que identificam plataformas – Device.iOS, Device.Android, Device.WinPhone(preterido), Device.WinRT (preterido), Device.UWPe Device.macOS. Da mesma forma, as Device.OnPlatform sobrecargas foram substituídas OnPlatform pelas APIs e On .

Em C#, os valores específicos da plataforma podem ser fornecidos criando uma switch instrução na Device.RuntimePlatform propriedade e, em seguida, fornecendo case instruções para as plataformas necessárias:

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);

As OnPlatform classes e On fornecem a mesma funcionalidade em 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>

A OnPlatform classe é uma classe genérica que deve ser instanciada com um x:TypeArguments atributo que corresponde ao tipo de destino. On Na classe , o Platform atributo pode aceitar um único string valor ou vários valores delimitados por vírgulasstring.

Importante

Fornecer um valor de atributo incorreto Platform na On classe não resultará em um erro. Em vez disso, o código será executado sem que o valor específico da plataforma seja aplicado.

Como alternativa, a OnPlatform extensão de marcação pode ser usada em XAML para personalizar a aparência da interface do usuário por plataforma. Para obter mais informações, consulte OnPlatform Markup Extension.

Device.Idiom

A Device.Idiom propriedade pode ser usada para alterar layouts ou funcionalidades, dependendo do dispositivo em que o aplicativo está sendo executado. A enumeração TargetIdiom contém os seguintes valores:

Telefone – dispositivos iPhone, iPod touch e Android com mais de 600 quedas^
Tablet – dispositivos iPad, Windows e dispositivos Android com mais de 600 quedas^
Área de trabalho – retornada apenas em aplicativos UWP em computadores da área de trabalho do Windows 10 (retorna Phone em dispositivos móveis do Windows, inclusive em cenários de Continuum)
TV – Dispositivos tizen TV
Assista – Dispositivos tizen watch
Sem suporte – não utilizado

^ dips não é necessariamente a contagem de pixels físicos

A Idiom propriedade é especialmente útil para criar layouts que aproveitam telas maiores, como esta:

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

A OnIdiom classe fornece a mesma funcionalidade no 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>

A OnIdiom classe é uma classe genérica que deve ser instanciada com um x:TypeArguments atributo que corresponde ao tipo de destino.

Como alternativa, a OnIdiom extensão de marcação pode ser usada em XAML para personalizar a aparência da interface do usuário com base no idioma do dispositivo em que o aplicativo está sendo executado. Para obter mais informações, consulte OnIdiom Markup Extension.

Device.FlowDirection

O Device.FlowDirection valor recupera um FlowDirection valor de enumeração que representa a direção de fluxo atual que está sendo usada pelo dispositivo. A direção do fluxo é a direção na qual os elementos de interface do usuário na página são detectados pelos olhos. Os valores de enumeração são:

No XAML, o Device.FlowDirection valor pode ser recuperado usando a x:Static extensão de marcação:

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

O código equivalente em C# é:

this.FlowDirection = Device.FlowDirection;

Para obter mais informações sobre a direção do fluxo, consulte Localização da direita para a esquerda.

Device.Styles

A Styles propriedade contém definições de estilo internas que podem ser aplicadas à propriedade de alguns controles (como Label). Style Os estilos disponíveis são:

Bodystyle
CaptionStyle
ListItemDetailTextStyle
ListItemTextStyle
SubtitleStyle
Titlestyle

Device.GetNamedSize

GetNamedSize pode ser usado ao definir FontSize no código 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 apresenta suporte para cores nomeadas. Uma cor nomeada é uma cor que tem um valor diferente dependendo de qual modo do sistema (por exemplo, claro ou escuro) está ativo no dispositivo. No Android, as cores nomeadas são acessadas por meio da classe R.Color . No iOS, as cores nomeadas são chamadas de cores do sistema. No Plataforma Universal do Windows, as cores nomeadas são chamadas de recursos de tema XAML.

O GetNamedColor método pode ser usado para recuperar cores nomeadas no Android, iOS e UWP. O método usa um string argumento e retorna um Color:

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

Color.Default será retornado quando um nome de cor não puder ser encontrado ou quando GetNamedColor for invocado em uma plataforma sem suporte.

Observação

Como o GetNamedColor método retorna um Color específico para uma plataforma, ele normalmente deve ser usado em conjunto com a Device.RuntimePlatform propriedade .

A NamedPlatformColor classe contém as constantes que definem as cores nomeadas para Android, iOS e 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

A Device classe também tem um StartTimer método que fornece uma maneira simples de disparar tarefas dependentes de tempo que funcionam em Xamarin.Forms código comum, incluindo uma biblioteca .NET Standard. Passe um TimeSpan para definir o intervalo e retorne true para manter o temporizador em execução ou false para interrompê-lo após a invocação atual.

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

Se o código dentro do temporizador interagir com a interface do usuário (como definir o texto de um Label ou exibir um alerta), ele deverá ser feito dentro de uma BeginInvokeOnMainThread expressão (veja abaixo).

Observação

As System.Timers.Timer classes e System.Threading.Timer são alternativas do .NET Standard para usar o Device.StartTimer método .

Interagir com a interface do usuário de threads em segundo plano

A maioria dos sistemas operacionais, incluindo iOS, Android e Plataforma Universal do Windows, usa um modelo de threading único para código que envolve a interface do usuário. Esse thread geralmente é chamado de thread main ou thread de interface do usuário. Uma consequência desse modelo é que todo o código que acessa elementos de interface do usuário deve ser executado no thread main do aplicativo.

Às vezes, os aplicativos usam threads em segundo plano para executar operações de execução potencialmente longas, como recuperar dados de um serviço Web. Se o código em execução em um thread em segundo plano precisar acessar elementos de interface do usuário, ele deverá executar esse código no thread main.

A Device classe inclui os seguintes static métodos que podem ser usados para interagir com elementos de interface do usuário de threads de planos de fundo:

Método	Argumentos	Retornos	Finalidade
`BeginInvokeOnMainThread`	`Action`	`void`	Invoca um `Action` no thread main e não aguarda a conclusão dele.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	Invoca um `Func<T>` no thread principal e aguarda sua conclusão.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Invoca um `Action` no thread principal e aguarda sua conclusão.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	Invoca um `Func<Task<T>>` no thread principal e aguarda sua conclusão.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	Invoca um `Func<Task>` no thread principal e aguarda sua conclusão.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	Retorna o `SynchronizationContext` para o thread principal.

O código a seguir mostra um exemplo de como usar o BeginInvokeOnMainThread método :

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