Xamarin.Forms v nativních projektech Xamarin

Stažení ukázky

Aplikace obvykle obsahuje jednu nebo více stránek odvozených z a tyto stránky jsou sdíleny všemi platformami v projektu knihovny .NET Standard nebo sdíleném Xamarin.FormsContentPage Project. Nativní formuláře však umožňují přidat odvozené stránky přímo do nativních aplikací ContentPage Xamarin.iOS, Xamarin.Android a UPW. V porovnání s tím, že nativní projekt spotřebovává stránky odvozené z projektu knihovny .NET Standard nebo sdíleného Project, výhodou přidávání stránek přímo do nativních projektů je, že stránky lze rozšířit o nativní ContentPage zobrazení. Nativní zobrazení je pak možné pojmenovat v XAML pomocí a x:Name odkazovat z kódu na pozadí. Další informace o nativních zobrazeních najdete v tématu Nativní zobrazení.

Proces využívání stránky Xamarin.FormsContentPage odvozené odvozované v nativním projektu je následující:

1. Přidejte Xamarin.Forms NuGet do nativního projektu.
2. Přidejte do nativního projektu stránku odvozenou a všechny ContentPage závislosti.
3. Zavolejte Forms.Init metodu .
4. Vytvořte instanci stránky odvozené od verze a převeďte ji na příslušný nativní typ pomocí jedné z následujících rozšiřujících metod: pro ContentPageCreateViewController iOS, Pro Android nebo pro CreateSupportFragmentCreateFrameworkElement UPW.
5. Pomocí nativního navigačního rozhraní API přejděte k reprezentaci nativního typu odvozené ContentPage stránky.

Xamarin.Forms musí být inicializován voláním metody předtím, než nativní Forms.Init projekt může vytvořit stránku ContentPage odvozenou od třídy . Volba, kdy to provést, závisí především na tom, kdy tok aplikace nejpohodlnější – může se provést při spuštění aplikace nebo těsně před tím, než se zkonstruuje stránka ContentPage odvozená od aplikace. V tomto článku a v doprovodných ukázkových aplikacích se Forms.Init volá metoda při spuštění aplikace.

Při použití nativních formulářů fungují všechny funkce, jako jsou , a modul Xamarin.FormsDependencyServiceMessagingCenter datových vazeb. Navigaci po stránce je však nutné provést pomocí nativního navigačního rozhraní API.

iOS

V iOSu je přepsání ve třídě obvykle místo, kde můžete provádět úlohy související FinishedLaunchingAppDelegate se spuštěním aplikace. Volá se po spuštění aplikace a obvykle se přepíše pro konfiguraci hlavního okna a kontroleru zobrazení. Následující příklad kódu ukazuje třídu AppDelegate v ukázkové aplikaci:

[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
    public static AppDelegate Instance;
    UIWindow _window;
    AppNavigationController _navigation;

    public static string FolderPath { get; private set; }

    public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
    {
        Forms.Init();

        // Create app-level resource dictionary.
        Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
        Xamarin.Forms.Application.Current.Resources = new MyDictionary();

        Instance = this;
        _window = new UIWindow(UIScreen.MainScreen.Bounds);

        UINavigationBar.Appearance.SetTitleTextAttributes(new UITextAttributes
        {
            TextColor = UIColor.Black
        });

        FolderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));

        NotesPage notesPage = new NotesPage()
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };

        UIViewController notesPageController = notesPage.CreateViewController();
        notesPageController.Title = "Notes";

        _navigation = new AppNavigationController(notesPageController);

        _window.RootViewController = _navigation;
        _window.MakeKeyAndVisible();

        notesPage.Parent = null;
        return true;
    }
    // ...
}

Metoda FinishedLaunching provádí následující úlohy:

• Xamarin.Forms je inicializován voláním Forms.Init metody .
• Vytvoří se nový objekt a jeho slovník prostředků na úrovni aplikace je nastavený na objekt Xamarin.Forms.ApplicationResourceDictionary definovaný v jazyce XAML.
• Odkaz na AppDelegate třídu je uložen v staticInstance poli . To poskytuje mechanismus pro jiné třídy pro volání metod definovaných ve AppDelegate třídě.
• Vytvoří UIWindow se , což je hlavní kontejner pro zobrazení v nativních aplikacích pro iOS.
• Vlastnost se inicializuje na cestu v zařízení, kam se FolderPath budou ukládat data poznámek.
• Vytvoří se objekt , což je odvozená stránka definovaná v jazyce XAML a jeho nadřazený objekt je NotesPage nastavený na dříve vytvořený Xamarin.FormsContentPageXamarin.Forms.Application objekt.
• Objekt NotesPage je převeden na objekt pomocí rozšiřující UIViewControllerCreateViewController metody.
• Vlastnost Title objektu UIViewController je nastavená, která se zobrazí v UINavigationBar objektu .
• Vytvoří AppNavigationController se pro správu hierarchické navigace. Toto je třída vlastního navigačního kontroleru odvozená z UINavigationController . Objekt spravuje zásobník kontrolerů zobrazení a předá se konstruktoru při načtení objektu AppNavigationControllerUIViewControllerAppNavigationController .
• Objekt je nastaven jako nejvyšší úroveň objektu a objekt je nastaven jako klíčové okno aplikace a AppNavigationControllerUIViewController je UIWindowUIWindow viditelný.
• Vlastnost Parent objektu je NotesPage nastavená na , aby se zabránilo null nevrácení paměti.

Po spuštění metody se zobrazí uživatelské rozhraní definované ve třídě FinishedLaunchingXamarin.FormsNotesPage , jak je znázorněno na následujícím snímku obrazovky:

s poznámkami na mobilním zařízení

Interakce s uživatelským rozhraním, například klepnutím na , bude mít za následek následující obslužnou rutinu události v provádění +Button kódu na NotesPage pozadí:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    AppDelegate.Instance.NavigateToNoteEntryPage(new Note());
}

Pole umožňuje vyvolání metody , což je znázorněno v staticAppDelegate.InstanceAppDelegate.NavigateToNoteEntryPage následujícím příkladu kódu:

public void NavigateToNoteEntryPage(Note note)
{
    NoteEntryPage noteEntryPage = new NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };

    var noteEntryViewController = noteEntryPage.CreateViewController();
    noteEntryViewController.Title = "Note Entry";

    _navigation.PushViewController(noteEntryViewController, true);
    noteEntryPage.Parent = null;
}

Metoda NavigateToNoteEntryPage převede stránku Xamarin.FormsContentPage odvozenou pomocí UIViewControllerCreateViewControllerTitle metody rozšíření na a nastaví vlastnost UIViewController objektu . Metoda UIViewController se pak do metody AppNavigationControllerPushViewController nasoudí. Proto se zobrazí uživatelské rozhraní definované ve Xamarin.FormsNoteEntryPage třídě , jak je znázorněno na následujícím snímku obrazovky:

Když se zobrazí , vrátí zpětná navigace pro třídu z a vrátí uživatele NoteEntryPageUIViewController do třídy NoteEntryPageAppNavigationControllerUIViewControllerNotesPage . Při vyřazení z nativního navigačního zásobníku pro iOS se však objekt a připojený objekt automaticky UIViewControllerUIViewController neuhodí. Page Třída proto přepisuje metodu , aby se na zpětné navigaci uchýlly AppNavigationControllerPopViewController kontrolery zobrazení:

public class AppNavigationController : UINavigationController
{
    //...
    public override UIViewController PopViewController(bool animated)
    {
        UIViewController topView = TopViewController;
        if (topView != null)
        {
            // Dispose of ViewController on back navigation.
            topView.Dispose();
        }
        return base.PopViewController(animated);
    }
}

Přepsání PopViewController volá Dispose metodu pro objekt UIViewController , který byl namáhnut ze zásobníku nativní navigace pro iOS. Pokud to neučiníte, osamocí se připojený UIViewControllerPage objekt a .

Android

V Androidu je přepsání ve třídě obvykle místo, kde můžete provádět úlohy OnCreateMainActivity související se spuštěním aplikace. Následující příklad kódu ukazuje třídu MainActivity v ukázkové aplikaci:

public class MainActivity : AppCompatActivity
{
    public static string FolderPath { get; private set; }

    public static MainActivity Instance;

    protected override void OnCreate(Bundle bundle)
    {
        base.OnCreate(bundle);

        Forms.Init(this, bundle);

        // Create app-level resource dictionary.
        Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
        Xamarin.Forms.Application.Current.Resources = new MyDictionary();

        Instance = this;

        SetContentView(Resource.Layout.Main);
        var toolbar = FindViewById<Toolbar>(Resource.Id.toolbar);
        SetSupportActionBar(toolbar);
        SupportActionBar.Title = "Notes";

        FolderPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData));

        NotesPage notesPage = new NotesPage()
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };
        AndroidX.Fragment.App.Fragment notesPageFragment = notesPage.CreateSupportFragment(this);

        SupportFragmentManager
            .BeginTransaction()
            .Replace(Resource.Id.fragment_frame_layout, mainPage)
            .Commit();
        //...

        notesPage.Parent = null;
    }
    ...
}

Metoda OnCreate provádí následující úlohy:

• Xamarin.Forms je inicializován voláním Forms.Init metody .
• Vytvoří se nový objekt a jeho slovník prostředků na úrovni aplikace je nastavený na objekt Xamarin.Forms.ApplicationResourceDictionary definovaný v jazyce XAML.
• Odkaz na MainActivity třídu je uložen v staticInstance poli . To poskytuje mechanismus pro jiné třídy pro volání metod definovaných ve MainActivity třídě.
• Obsah Activity se nastaví z prostředku rozložení. V ukázkové aplikaci se rozložení skládá z objektu , který obsahuje objekt , a , který bude LinearLayoutToolbar fungovat jako kontejner FrameLayout fragmentu.
• Objekt Toolbar se načte a nastaví jako panel akcí a nastaví se název panelu Activity akcí.
• Vlastnost se inicializuje na cestu v zařízení, kam se FolderPath budou ukládat data poznámek.
• Vytvoří se objekt , což je odvozená stránka definovaná v jazyce XAML a jeho nadřazený objekt je NotesPage nastavený na dříve vytvořený Xamarin.FormsContentPageXamarin.Forms.Application objekt.
• Objekt NotesPage je převeden na objekt pomocí rozšiřující FragmentCreateSupportFragment metody.
• Třída SupportFragmentManager vytvoří a potvrdí transakci, která nahradí instanci FrameLayoutFragmentNotesPage třídou .
• Vlastnost Parent objektu je NotesPage nastavená na , aby se zabránilo null nevrácení paměti.

Další informace o fragmentech najdete v tématu Fragmenty.

Po spuštění metody se zobrazí uživatelské rozhraní definované ve třídě OnCreateXamarin.FormsNotesPage , jak je znázorněno na následujícím snímku obrazovky:

rozhraním XAML Snímek obrazovky s poznámkami na mobilním zařízení s modrým

Interakce s uživatelským rozhraním, například klepnutím na , bude mít za následek následující obslužnou rutinu události v provádění +Button kódu na NotesPage pozadí:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    MainActivity.Instance.NavigateToNoteEntryPage(new Note());
}

Pole umožňuje vyvolání metody , což je znázorněno v staticMainActivity.InstanceMainActivity.NavigateToNoteEntryPage následujícím příkladu kódu:

public void NavigateToNoteEntryPage(Note note)
{
    NoteEntryPage noteEntryPage = new NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };

    AndroidX.Fragment.App.Fragment noteEntryFragment = noteEntryPage.CreateSupportFragment(this);
    SupportFragmentManager
        .BeginTransaction()
        .AddToBackStack(null)
        .Replace(Resource.Id.fragment_frame_layout, noteEntryFragment)
        .Commit();

    noteEntryPage.Parent = null;
}

Metoda převede stránku odvozenou pomocí metody rozšíření na a přidá do NavigateToNoteEntryPageXamarin.FormsContentPageFragmentCreateSupportFragmentFragment zásobníku zpět fragmentu . Proto se zobrazí uživatelské rozhraní definované v Xamarin.FormsNoteEntryPage , jak je znázorněno na následujícím snímku obrazovky:

Snímek obrazovky znázorňuje položku poznámky na mobilním zařízení s

Když se zobrazí , klepnutím na šipku zpět se z zásobníku zpět fragmentu vysunutím vrátí uživatel do třídy NoteEntryPageFragmentNoteEntryPageFragmentNotesPage .

Povolení podpory back navigation

Třída SupportFragmentManager má BackStackChanged událost, která se vyžádá vždy, když se změní obsah zásobníku zpět fragmentu. Metoda OnCreate ve třídě obsahuje anonymní MainActivity obslužnou rutinu události pro tuto událost:

SupportFragmentManager.BackStackChanged += (sender, e) =>
{
    bool hasBack = SupportFragmentManager.BackStackEntryCount > 0;
    SupportActionBar.SetHomeButtonEnabled(hasBack);
    SupportActionBar.SetDisplayHomeAsUpEnabled(hasBack);
    SupportActionBar.Title = hasBack ? "Note Entry" : "Notes";
};

Tato obslužná rutina události zobrazí na panelu akcí tlačítko Zpět za předpokladu, že je v zásobníku fragmentu jedna nebo více Fragment instancí. Odpověď na klepnutí na tlačítko Zpět se zpracovává OnOptionsItemSelected přepsáním:

public override bool OnOptionsItemSelected(Android.Views.IMenuItem item)
{
    if (item.ItemId == global::Android.Resource.Id.Home && SupportFragmentManager.BackStackEntryCount > 0)
    {
        SupportFragmentManager.PopBackStack();
        return true;
    }
    return base.OnOptionsItemSelected(item);
}

Přepsání OnOptionsItemSelected se volá vždy, když je vybrána položka v nabídce možností. Tato implementace vysunout aktuální fragment ze zásobníku zpět fragmentu za předpokladu, že bylo vybráno tlačítko Zpět a v zásobníku fragmentu je jedna nebo více Fragment instancí.

Více aktivit

Pokud se aplikace skládá z více aktivit, mohou být do každé aktivity vloženy odvozené ContentPage stránky. V tomto scénáři je potřeba volat metodu pouze v přepsání první Forms.InitOnCreate metody, Activity která vkládá Xamarin.FormsContentPage . To má ale následující dopad:

• Hodnota bude Xamarin.Forms.Color.Accent převzata z metody Activity , která se nazývá metoda Forms.Init .
• Hodnota Xamarin.Forms.Application.Current bude přidružena k Activity metodě, která se nazývá Forms.Init metoda.

Zvolit soubor

Při vložení ContentPage stránky odvozené od, která používá a WebView který potřebuje podporovat HTML tlačítko zvolit soubor, Activity bude nutné přepsat OnActivityResult metodu:

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);
    ActivityResultCallbackRegistry.InvokeCallback(requestCode, resultCode, data);
}

UWP

Na UWP App je nativní třída obvykle místem pro provádění úloh souvisejících s spuštěním aplikace. Xamarin.Forms je obvykle inicializován v Xamarin.Forms aplikacích UWP v OnLaunched přepsání v nativní App třídě pro předání LaunchActivatedEventArgs argumentu Forms.Init metodě. Z tohoto důvodu mohou nativní aplikace UWP, které využívají Xamarin.FormsContentPage odvozené stránky, snadno volat Forms.Init metodu z App.OnLaunched metody:

protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // ...
    Xamarin.Forms.Forms.Init(e);

    // Create app-level resource dictionary.
    Xamarin.Forms.Application.Current = new Xamarin.Forms.Application();
    Xamarin.Forms.Application.Current.Resources = new MyDictionary();

    // ...
}

Kromě toho OnLaunched může metoda také vytvořit libovolný slovník prostředků na úrovni aplikace, který je vyžadován aplikací.

Ve výchozím nastavení nativní App Třída spustí MainPage třídu jako první stránku aplikace. Následující příklad kódu ukazuje MainPage třídu v ukázkové aplikaci:

public sealed partial class MainPage : Page
{
    NotesPage notesPage;
    NoteEntryPage noteEntryPage;

    public static MainPage Instance;
    public static string FolderPath { get; private set; }

    public MainPage()
    {
        this.NavigationCacheMode = NavigationCacheMode.Enabled;
        Instance = this;
        FolderPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData));

        notesPage = new Notes.UWP.Views.NotesPage
        {
            // Set the parent so that the app-level resource dictionary can be located.
            Parent = Xamarin.Forms.Application.Current
        };
        this.Content = notesPage.CreateFrameworkElement();
        // ...
        notesPage.Parent = null;    
    }
    // ...
}

MainPageKonstruktor provádí následující úlohy:

• Ukládání do mezipaměti je pro stránku povoleno, takže nový MainPage není vytvořen v případě, že uživatel přejde zpět na stránku.
• Odkaz na MainPage třídu je uložen v staticInstance poli. Slouží k poskytnutí mechanismu pro jiné třídy pro volání metod definovaných ve MainPage třídě.
• FolderPathVlastnost je inicializována do cesty na zařízení, kde jsou uložena data poznámky.
• Vytvoří se NotesPage objekt, což je Xamarin.FormsContentPage odvozená stránka definovaná v jazyce XAML a její nadřazený objekt je nastaven na dříve vytvořený Xamarin.Forms.Application objekt.
• NotesPageObjekt je převeden na FrameworkElement pomocí CreateFrameworkElement metody rozšíření a poté nastaven jako obsah MainPage třídy.
• ParentVlastnost NotesPage objektu je nastavena na hodnotu null , aby nedošlo k nevrácení paměti.

Po MainPage spuštění konstruktoru se zobrazí uživatelské rozhraní definované ve Xamarin.FormsNotesPage třídě, jak je znázorněno na následujícím snímku obrazovky:

Aplikace Xamarin. Forms XAML UI "data-LINKTYPE =" relativní-Path "> Xamarin. Forms XAML UI "data-LINKTYPE =" relativní cesta "/>

Interakce s uživatelským rozhraním, například klepnutím na +Button , způsobí následující obslužnou rutinu události v průběhu NotesPage provádění kódu:

void OnNoteAddedClicked(object sender, EventArgs e)
{
    MainPage.Instance.NavigateToNoteEntryPage(new Note());
}

staticMainPage.Instance Pole umožňuje MainPage.NavigateToNoteEntryPage vyvolání metody, která je uvedena v následujícím příkladu kódu:

public void NavigateToNoteEntryPage(Note note)
{
    noteEntryPage = new Notes.UWP.Views.NoteEntryPage
    {
        BindingContext = note,
        // Set the parent so that the app-level resource dictionary can be located.
        Parent = Xamarin.Forms.Application.Current
    };
    this.Frame.Navigate(noteEntryPage);
    noteEntryPage.Parent = null;
}

Navigace v UWP se obvykle provádí s Frame.Navigate metodou, která přebírá Page argument. Xamarin.Forms definuje Frame.Navigate metodu rozšíření, která přebírá ContentPage instanci stránky odvozenou od třídy. Proto když se NavigateToNoteEntryPage Metoda spustí, zobrazí se uživatelské rozhraní definované v Xamarin.FormsNoteEntryPage , jak je znázorněno na následujícím snímku obrazovky:

Aplikace Xamarin. Forms XAML UI "data-LINKTYPE =" relativní-Path "> Xamarin. Forms XAML UI "data-LINKTYPE =" relativní cesta "/>

Když se NoteEntryPage zobrazí, klepnutím na šipku zpět se zobrazí okno FrameworkElementNoteEntryPage z zásobníku back-App, ve kterém se vrátí uživatel pro FrameworkElementNotesPage třídu.

Povolit podporu změny velikosti stránky

Při změně velikosti okna aplikace UWP Xamarin.Forms by se měla změnit také velikost obsahu. K tomu je možné provést registraci obslužné rutiny události pro Loaded událost v MainPage konstruktoru:

public MainPage()
{
    // ...
    this.Loaded += OnMainPageLoaded;
    // ...
}

LoadedUdálost je aktivována, když je stránka rozložena, vykreslena a připravena pro interakci a provede OnMainPageLoaded metodu v reakci:

void OnMainPageLoaded(object sender, RoutedEventArgs e)
{
    this.Frame.SizeChanged += (o, args) =>
    {
        if (noteEntryPage != null)
            noteEntryPage.Layout(new Xamarin.Forms.Rectangle(0, 0, args.NewSize.Width, args.NewSize.Height));
        else
            notesPage.Layout(new Xamarin.Forms.Rectangle(0, 0, args.NewSize.Width, args.NewSize.Height));
    };
}

OnMainPageLoadedMetoda zaregistruje obslužnou rutinu anonymní události pro Frame.SizeChanged událost, která je vyvolána, když se ActualHeightActualWidth změní vlastnosti nebo v Frame . V reakci se Xamarin.Forms Velikost obsahu pro aktivní stránku mění pomocí volání Layout metody.

Povolit podporu navigace zpět

V případě UWP musí aplikace povolit zpětnou navigaci pro všechna tlačítka hardwaru a softwaru, a to v různých faktorech formuláře zařízení. To lze provést registrací obslužné rutiny události pro BackRequested událost, která může být provedena v MainPage konstruktoru:

public MainPage()
{
    // ...
    SystemNavigationManager.GetForCurrentView().BackRequested += OnBackRequested;
}

Při spuštění aplikace GetForCurrentView Metoda načte SystemNavigationManager objekt přidružený k aktuálnímu zobrazení a poté zaregistruje obslužnou rutinu události pro BackRequested událost. Aplikace přijímá tuto událost pouze v případě, že se jedná o aplikaci v popředí a v reakci volá OnBackRequested obslužnou rutinu události:

void OnBackRequested(object sender, BackRequestedEventArgs e)
{
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame.CanGoBack)
    {
        e.Handled = true;
        rootFrame.GoBack();
        noteEntryPage = null;
    }
}

OnBackRequestedObslužná rutina události volá GoBack metodu v kořenovém rámci aplikace a nastaví BackRequestedEventArgs.Handled vlastnost na k true označení události jako zpracovávaného. Nepovedlo se označit událost jako zpracovanou, protože by mohlo dojít k ignorování události.

Aplikace zvolí, zda má být v záhlaví zobrazeno tlačítko zpět. Toho lze dosáhnout nastavením AppViewBackButtonVisibility vlastnosti na jednu z AppViewBackButtonVisibility hodnot výčtu ve App třídě:

void OnNavigated(object sender, NavigationEventArgs e)
{
    SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
        ((Frame)sender).CanGoBack ? AppViewBackButtonVisibility.Visible : AppViewBackButtonVisibility.Collapsed;
}

OnNavigatedObslužná rutina události, která je spuštěna v reakci na Navigated aktivaci události, aktualizuje viditelnost tlačítka záhlaví zpět, když dojde k navigaci stránky. Tím se zajistí, že se tlačítko zpět v záhlaví zobrazí, pokud není zásobník back-aplikace prázdný nebo odebraný z záhlaví, pokud je zásobník back-aplikace prázdný.

Další informace o podpoře zpětné navigace na UWP najdete v tématu historie navigace a zpětná navigace pro aplikace pro UWP.

Související odkazy

• NativeForms (ukázka)
• Nativní zobrazení