Xamarin.Forms Classe de 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 o 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.
Forneça valores específicos da plataforma
Antes da Xamarin.Forms versão 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 de enumeração , TargetPlatform.Android, TargetPlatform.WinPhone, e TargetPlatform.Windows . Da mesma forma, uma das sobrecargas pode 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 descontinuadas 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(obsoleta), Device.WinRT (obsoleta), Device.UWPe Device.macOS. Da mesma forma, as Device.OnPlatform sobrecargas foram substituídas pelas OnPlatform APIs e On .
Em C#, os valores específicos da Device.RuntimePlatform plataforma podem ser fornecidos criando uma switch instrução na 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 and 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 Platform atributo pode aceitar um único string valor ou vários valores delimitados por string vírgulasOn.
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 com mais de 600 mergulhos^
- Tablet – iPad, dispositivos Windows e dispositivos Android com mais de 600 mergulhos^
- Área de trabalho – retornado apenas em aplicativos UWP em computadores desktop Windows 10 (retorna
Phoneem dispositivos móveis Windows, inclusive em cenários Continuum) - TV – Dispositivos de TV Tizen
- Assista – Dispositivos de relógio Tizen
- Não suportado – não utilizado
^ Dips não é necessariamente a contagem física de pixels
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 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 Extensão de marcação OnIdiom.
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 extensão de x:Static 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 de corpo
- Estilo de legenda
- ListItemDetailTextStyle
- ListItemTextStyle
- Estilo de legenda
- Estilo de 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 recebe 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 de 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 a TimeSpan para definir o intervalo e retorne true para manter o cronômetro 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), isso deverá ser feito dentro de uma BeginInvokeOnMainThread expressão (veja abaixo).
Observação
As System.Timers.Timer classes and 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 que envolve 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 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 uso do BeginInvokeOnMainThread método:
Device.BeginInvokeOnMainThread (() =>
{
// interact with UI elements
});