Compartilhar via


Xamarin.Forms Classe do dispositivo

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 a partir 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 sendo executado podia ser obtida examinando a Device.OS propriedade e comparando-a com os TargetPlatform.iOSvalores , TargetPlatform.Android, TargetPlatform.WinPhonee TargetPlatform.Windows enumeração. Da mesma forma, uma das sobrecargas poderia ser usada para fornecer valores específicos da Device.OnPlatform plataforma para um controle.

No entanto, desde Xamarin.Forms a versão 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.WinPhonepreterido), Device.WinRT (preterido) Device.UWPe Device.macOS. Da mesma forma, as Device.OnPlatform sobrecargas foram substituídas pelas OnOnPlatform e APIs.

Em C#, os valores específicos da plataforma podem ser fornecidos criando uma switch instrução na propriedade e, em Device.RuntimePlatform 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 corresponda ao tipo de destino. Na classe, o OnPlatform atributo pode aceitar um único string valor ou vários valores delimitados string por vírgula.

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 Extensão de marcação OnPlatform.

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 – iPhone, iPod touch e dispositivos Android mais estreitos do que 600 mergulhos ^
  • Tablet – iPad, dispositivos Windows e dispositivos Android com mais de 600 mergulhos ^
  • Área de trabalho – retornada somente em aplicativos UWP em computadores desktop Windows 10 (retorna Phone em dispositivos móveis Windows, inclusive em cenários Continuum)
  • TV – Dispositivos de TV Tizen
  • Watch – Dispositivos de relógio Tizen
  • Sem suporte – não utilizado

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

A Idiom propriedade é especialmente útil para construir 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 em 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 corresponda 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 do 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:

Em 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:

  • Estilo do corpo
  • CaptionStyle
  • ListItemDetailTextStyle
  • ListItemTextStyle
  • Estilo de Legenda
  • Estilo do título

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 introduz 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. Na 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 que é 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 do tempo que funciona em Xamarin.Forms código comum, incluindo uma biblioteca do .NET Standard. Passe a TimeSpan para definir o intervalo e retorne true para manter o temporizador em execução ou false para pará-lo após a chamada 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), isso deve 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 a partir de threads em segundo plano

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

Às vezes, os aplicativos usam threads em segundo plano para executar operações 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 da interface do usuário, ele deverá executar esse código no thread principal.

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

Método Argumentos Devoluções Finalidade
BeginInvokeOnMainThread Action void Invoca um Action no thread principal e não espera que ele seja concluído.
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
});