Xamarin.Forms Třída zařízení

Článek
03/05/2024

Třída Device obsahuje řadu vlastností a metod, které vývojářům pomáhají přizpůsobit rozložení a funkce na základě jednotlivých platforem.

Kromě metod a vlastností pro cílení kódu na konkrétní typy a velikosti hardwaru třída obsahuje metody, Device které lze použít k interakci s ovládacími prvky uživatelského rozhraní z vláken na pozadí. Další informace naleznete v tématu Interakce s uživatelským rozhraním z vláken na pozadí.

Zadání hodnot specifických pro platformu

Xamarin.Forms Před verzí 2.3.4 bylo možné získat platformu, na které aplikace běží, prozkoumáním Device.OS vlastnosti a porovnáním s TargetPlatform.iOShodnotami , TargetPlatform.Android, TargetPlatform.WinPhonea TargetPlatform.Windows výčtu. Podobně lze jednu z Device.OnPlatform přetížení použít k poskytnutí hodnot specifických pro platformu ovládacímu prvku.

Od Xamarin.Forms verze 2.3.4 jsou však tato rozhraní API zastaralá a nahrazena. Třída Device nyní obsahuje veřejné řetězcové konstanty, které identifikují platformy – Device.iOS, Device.Android, Device.WinPhone(zastaralé), (zastaralé) Device.WinRTDevice.UWPa Device.macOS. Device.OnPlatform Podobně byla přetížení nahrazena rozhraními API a On rozhraními OnPlatform API.

V jazyce C# je možné hodnoty specifické pro platformu poskytnout vytvořením switch příkazu pro Device.RuntimePlatform vlastnost a následným zadáním case příkazů pro požadované platformy:

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

On Třídy OnPlatform poskytují stejné funkce v 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>

Třída OnPlatform je obecná třída, která musí být vytvořena s atributem x:TypeArguments , který odpovídá cílovému typu. On Ve třídě Platform může atribut přijmout jednu string hodnotu nebo více hodnot oddělených string čárkami.

Důležité

Poskytnutí nesprávné Platform hodnoty atributu On ve třídě nebude mít za následek chybu. Místo toho se kód spustí bez použití hodnoty specifické pro platformu.

OnPlatform Rozšíření značek můžete také použít v XAML k přizpůsobení vzhledu uživatelského rozhraní na základě jednotlivých platforem. Další informace naleznete v tématu OnPlatform Markup Extension.

Device.Idiom

Device.Idiom Vlastnost lze použít ke změně rozložení nebo funkčnosti v závislosti na zařízení, na kterém aplikace běží. Výčet TargetIdiom obsahuje následující hodnoty:

Telefon – i Telefon, iPod touch a zařízení s Androidem užší než 600 dipů^
Tablet – iPad, zařízení s Windows a zařízení s Androidem širší než 600 dipů^
Desktop – vrací se jenom v aplikacích pro UPW na stolních počítačích s Windows 10 (vrací se Phone na mobilních zařízeních s Windows, včetně scénářů Continuum)
TV – Tizen TV zařízení
Hodinky – Tizen watch devices
Nepodporované – nepoužívané

^ poklesy nemusí nutně odpovídat počtu fyzických pixelů.

Vlastnost Idiom je zvlášť užitečná pro rozložení budov, která využívají větší obrazovky, například takto:

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

Třída OnIdiom poskytuje stejné funkce v 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>

Třída OnIdiom je obecná třída, která musí být vytvořena s atributem x:TypeArguments , který odpovídá cílovému typu.

Alternativně OnIdiom lze rozšíření značek použít v XAML k přizpůsobení vzhledu uživatelského rozhraní na základě iddiomu zařízení, na kterém aplikace běží. Další informace naleznete v tématu OnIdiom Markup Extension.

Device.FlowDirection

Tato Device.FlowDirection hodnota načte hodnotu výčtu FlowDirection , která představuje aktuální směr toku používaný zařízením. Směr toku je směr, ve kterém jsou prvky uživatelského rozhraní na stránce naskenovány okem. Hodnoty výčtu jsou:

V jazyce XAML Device.FlowDirection je možné tuto hodnotu načíst pomocí x:Static rozšíření značek:

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

Ekvivalentní kód v jazyce C# je:

this.FlowDirection = Device.FlowDirection;

Další informace o směru toku naleznete v tématu Lokalizace zprava doleva.

Device.Styles

Vlastnost Styles obsahuje předdefinované definice stylu, které lze použít u některých ovládacích prvků (napříkladLabel) Style vlastnosti. Dostupné styly jsou:

Bodystyle
Titulek – styl
ListItemDetailTextStyle
ListItemTextStyle
Podnadpis
Styl nadpisu

Device.GetNamedSize

GetNamedSize lze použít při nastavování FontSize v kódu jazyka 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 zavádí podporu pojmenovaných barev. Pojmenovaná barva je barva, která má jinou hodnotu v závislosti na tom, jaký systémový režim (například světlý nebo tmavý) je v zařízení aktivní. V Androidu jsou pojmenované barvy přístupné prostřednictvím třídy R.Color . V iOSu se pojmenované barvy nazývají systémové barvy. Na Univerzální platforma Windows se pojmenované barvy nazývají prostředky motivu XAML.

Tuto metodu GetNamedColor lze použít k načtení pojmenovaných barev v Androidu, iOSu a UPW. Metoda vezme string argument a vrátí Color:

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

Color.Default bude vrácena, pokud nelze najít název barvy nebo při GetNamedColor vyvolání na nepodporované platformě.

Poznámka:

GetNamedColor Vzhledem k tomu, že metoda vrací konkrétní Color platformu, měla by se obvykle používat ve spojení s Device.RuntimePlatform vlastností.

Třída NamedPlatformColor obsahuje konstanty, které definují pojmenované barvy pro Android, iOS a UPW:

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

Třída Device má také metodu StartTimer , která poskytuje jednoduchý způsob, jak aktivovat úkoly závislé na čase, které fungují v Xamarin.Forms běžném kódu, včetně knihovny .NET Standard. TimeSpan Předejte interval a vraťte true se, aby časovač běžel nebo false ho zastavil po aktuálním vyvolání.

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

Pokud kód uvnitř časovače komunikuje s uživatelským rozhraním (například nastavením textu Label nebo zobrazení výstrahy), měl by být proveden uvnitř výrazu BeginInvokeOnMainThread (viz níže).

Poznámka:

Třídy System.Timers.Timer jsou System.Threading.Timer alternativy rozhraní .NET Standard k použití Device.StartTimer metody.

Interakce s uživatelským rozhraním z vláken na pozadí

Většina operačních systémů, včetně iOS, Androidu a Univerzální platforma Windows, používá pro kód zahrnující uživatelské rozhraní model s jedním vláknem. Toto vlákno se často označuje jako hlavní vlákno nebo vlákno uživatelského rozhraní. Důsledkem tohoto modelu je, že veškerý kód, který přistupuje k prvkům uživatelského rozhraní, musí běžet v hlavním vlákně aplikace.

Aplikace někdy používají vlákna na pozadí k provádění potenciálně dlouhotrvajících operací, jako je načítání dat z webové služby. Pokud kód spuštěný ve vlákně na pozadí potřebuje přístup k prvkům uživatelského rozhraní, musí tento kód spustit v hlavním vlákně.

Třída Device obsahuje následující static metody, které lze použít k interakci s prvky uživatelského rozhraní z vláken pozadí:

metoda	Argumenty	Návraty	Účel
`BeginInvokeOnMainThread`	`Action`	`void`	Vyvolá hlavní `Action` vlákno a nečeká na jeho dokončení.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	`Func<T>` Vyvolá hlavní vlákno a počká na jeho dokončení.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Vyvolá hlavní `Action` vlákno a počká na jeho dokončení.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	`Func<Task<T>>` Vyvolá hlavní vlákno a počká na jeho dokončení.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	`Func<Task>` Vyvolá hlavní vlákno a počká na jeho dokončení.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	`SynchronizationContext` Vrátí hodnotu pro hlavní vlákno.

Následující kód ukazuje příklad použití BeginInvokeOnMainThread metody:

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