Xamarin.Forms v nativních projektech Xamarinu

Článek
02/01/2021

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

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

Xamarin.Forms Přidejte balíček NuGet do nativního projektu.
ContentPagePřidejte do nativního projektu stránku -odvozenou a všechny závislosti.
Zavolejte metodu Forms.Init .
Pomocí jedné z následujících metod rozšíření vytvořte instanci ContentPageodvozené stránky a převeďte ji na příslušný nativní typ: CreateViewController pro iOS, CreateSupportFragment Android nebo CreateFrameworkElement UPW.
Pomocí nativního navigačního ContentPagerozhraní API přejděte na nativní reprezentaci typu odvozené stránky.

Xamarin.Forms musí být inicializován voláním Forms.Init metody, aby nativní projekt mohl vytvořit -odvozenou ContentPagestránku. Volba, kdy to provést, závisí především na tom, kdy je to v toku aplikace nejvhodnější – může se provést při spuštění aplikace nebo těsně před ContentPagevytvořením odvozené stránky. V tomto článku a doprovodné ukázkové aplikace se Forms.Init metoda nazývá při spuštění aplikace.

Poznámka:

Ukázkové aplikační řešení NativeForms neobsahuje žádné Xamarin.Forms projekty. Místo toho se skládá z projektu Xamarin.iOS, projektu Xamarin.Android a projektu UPW. Každý projekt je nativní projekt, který používá nativní formuláře k využívání ContentPageodvozených stránek. Neexistuje ale žádný důvod, proč nativní projekty nemohly využívat ContentPagestránky odvozené z projektu knihovny .NET Standard nebo sdíleného projektu.

Při použití nativních formulářů, funkcí, Xamarin.Forms jako DependencyServiceje , MessagingCentera modulu datových vazeb, všechny stále fungují. Navigace na stránce se ale musí provádět pomocí nativního navigačního rozhraní API.

iOS

V iOSu FinishedLaunchingAppDelegate je přepsání ve třídě obvykle místem pro provádění úloh souvisejících se spuštěním aplikace. Volá se po spuštění aplikace a obvykle se přepíše tak, aby nakonfiguroval hlavní okno a kontroler zobrazení. Následující příklad kódu ukazuje AppDelegate třídu 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 inicializuje voláním Forms.Init metody.
Vytvoří se nový Xamarin.Forms.Application objekt a jeho slovník prostředků na úrovni aplikace se nastaví na ResourceDictionary definovaný v XAML.
Odkaz na AppDelegate třídu je uložen v staticInstance poli. Toto je poskytnout mechanismus pro jiné třídy volání metod definovaných AppDelegate ve třídě.
Vytvoří se UIWindowhlavní kontejner pro zobrazení v nativních aplikacích pro iOS.
Vlastnost FolderPath se inicializuje na cestu v zařízení, kde budou uložena data poznámek.
Vytvoří NotesPage se objekt, což je Xamarin.FormsContentPage-odvozená stránka definovaná v xaml a jeho nadřazený objekt je nastaven na dříve vytvořený Xamarin.Forms.Application objekt.
Objekt NotesPage je převeden na metodu UIViewControllerCreateViewController rozšíření.
Vlastnost TitleUIViewController je nastavena, která bude zobrazena na .UINavigationBar
Vytvoří AppNavigationController se pro správu hierarchické navigace. Jedná se o vlastní třídu kontroleru navigace, která je odvozena od UINavigationController. Objekt AppNavigationController spravuje zásobník kontrolerů zobrazení a UIViewController předaný do konstruktoru se zobrazí zpočátku při AppNavigationController načtení.
Objekt AppNavigationController je nastaven jako nejvyšší úroveň UIViewController pro UIWindowobjekt a UIWindow je nastaven jako klíčové okno aplikace a je viditelné.
Vlastnost Parent objektu NotesPage je nastavena na null, aby se zabránilo nevracení paměti.

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

Důležité

Všechny ContentPage-odvozené stránky mohou využívat prostředky definované na úrovni ResourceDictionaryaplikace za předpokladu, že Parent vlastnost stránky je nastavena na Application objekt.

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

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

Pole staticAppDelegate.Instance umožňuje AppDelegate.NavigateToNoteEntryPage vyvolání metody, která je znázorněna v 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 Xamarin.FormsContentPage-odvozenou UIViewController stránku na s CreateViewController rozšiřující metodou a nastaví Title vlastnost UIViewController. Metoda UIViewController se pak nasdílí AppNavigationControllerPushViewController . 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:

NoteEntryPage Po zobrazení se zpět navigace zobrazí UIViewController pro NoteEntryPage třídu z objektu AppNavigationController, který vrací uživatele do UIViewControllerNotesPage třídy. Popping z UIViewController nativního navigačního zásobníku iOS však automaticky neodstraní UIViewController a připojený Page objekt. AppNavigationController Třída proto přepíše metoduPopViewController, aby na zpětné navigaci vyřaďte 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á metodu Dispose u objektu UIViewController , který byl vynechán z nativního navigačního zásobníku pro iOS. Pokud to neuděláte, dojde k osiření objektu a připojeného Page objektuUIViewController.

Důležité

Osamocené objekty nemohou být uvolněny z paměti, takže výsledkem je nevracení paměti.

Android

V Androidu OnCreateMainActivity je přepsání třídy obvykle místem pro provádění úloh souvisejících se spuštěním aplikace. Následující příklad kódu ukazuje MainActivity třídu 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 inicializuje voláním Forms.Init metody.
Vytvoří se nový Xamarin.Forms.Application objekt a jeho slovník prostředků na úrovni aplikace se nastaví na ResourceDictionary definovaný v XAML.
Odkaz na MainActivity třídu je uložen v staticInstance poli. Toto je poskytnout mechanismus pro jiné třídy volání metod definovaných MainActivity ve třídě.
Obsah Activity je nastavený z prostředku rozložení. V ukázkové aplikaci se rozložení skládá z objektu LinearLayout , který obsahuje objekt a Toolbarkterý FrameLayout se má chovat jako kontejner fragmentů.
Načte Toolbar se a nastaví jako panel akcí pro Activitypanel akcí a nastaví se záhlaví panelu akcí.
Vlastnost FolderPath se inicializuje na cestu v zařízení, kde budou uložena data poznámek.
Vytvoří NotesPage se objekt, což je Xamarin.FormsContentPage-odvozená stránka definovaná v xaml a jeho nadřazený objekt je nastaven na dříve vytvořený Xamarin.Forms.Application objekt.
Objekt NotesPage je převeden na metodu FragmentCreateSupportFragment rozšíření.
Třída SupportFragmentManager vytvoří a potvrdí transakci, která nahradí FrameLayout instanci Fragment za třídu NotesPage .
Vlastnost Parent objektu NotesPage je nastavena na null, aby se zabránilo nevracení paměti.

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

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

Důležité

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

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

Pole staticMainActivity.Instance umožňuje MainActivity.NavigateToNoteEntryPage vyvolání metody, která je znázorněna v 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 NavigateToNoteEntryPage převedeContentPageXamarin.Forms -odvozenou Fragment stránku na metodu CreateSupportFragment rozšíření a přidá do zásobníku zpět fragmentuFragment. Proto se zobrazí uživatelské rozhraní definované v sadě Xamarin.FormsNoteEntryPage , jak je znázorněno na následujícím snímku obrazovky:

NoteEntryPage Po zobrazení se klepnutím na šipku zpět zobrazí Fragment šipka pro NoteEntryPage část ze zásobníku zpět fragmentu a vrátí uživatele do FragmentNotesPage třídy.

Třída SupportFragmentManager má BackStackChanged událost, která se aktivuje pokaždé, když se změní obsah zásobníku fragmentu zpět. Metoda OnCreate ve MainActivity třídě obsahuje anonymní 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 back fragmentu jedna nebo více Fragment instancí. Odpověď na klepnutí na tlačítko Zpět se zpracuje přepsáním OnOptionsItemSelected :

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 zobrazí 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 zpět fragmentu je jedna nebo více Fragment instancí.

Více aktivit

Pokud se aplikace skládá z více aktivit, ContentPagelze do každé aktivity vložit odvozené stránky. V tomto scénáři se metoda musí volat pouze v OnCreate přepsání prvníhoActivity, Forms.Init který vloží Xamarin.FormsContentPage. To ale má následující dopad:

Hodnota Xamarin.Forms.Color.Accent bude převzata z Activity té, která volala metodu Forms.Init .
Hodnota Xamarin.Forms.Application.Current bude přidružena k Activity tomu, který se nazývá Forms.Init metoda.

Zvolit soubor

Při vkládání ContentPage-odvozené stránky, která používá, která potřebuje WebView podporovat html tlačítko Zvolit soubor, Activity bude nutné přepsat metodu OnActivityResult :

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

UWP

V UPW je nativní App třída obvykle místem pro provádění úloh souvisejících se spuštěním aplikace. Xamarin.Forms je obvykle inicializován v Xamarin.Forms aplikacích UPW v přepsání v OnLaunched nativní App třídě, aby předal LaunchActivatedEventArgs argument metodě Forms.Init . Z tohoto důvodu můžou nativní aplikace UPW, které využívají -odvozenou Xamarin.FormsContentPagestránku, nejsnáz volat metodu Forms.InitApp.OnLaunched z 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ý aplikace vyžaduje.

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;    
    }
    // ...
}

Konstruktor MainPage provádí následující úlohy:

Ukládání do mezipaměti je pro stránku povolená, takže když uživatel přejde zpět na stránku, nevykonstruuje se novýMainPage.
Odkaz na MainPage třídu je uložen v staticInstance poli. Toto je poskytnout mechanismus pro jiné třídy volání metod definovaných MainPage ve třídě.
Vlastnost FolderPath se inicializuje na cestu v zařízení, kde budou uložena data poznámek.
Vytvoří NotesPage se objekt, což je Xamarin.FormsContentPage-odvozená stránka definovaná v xaml a jeho nadřazený objekt je nastaven na dříve vytvořený Xamarin.Forms.Application objekt.
Objekt NotesPage je převeden na FrameworkElement pomocí CreateFrameworkElement rozšiřující metody a pak je nastaven jako obsah MainPage třídy.
Vlastnost Parent objektu NotesPage je nastavena na null, aby se zabránilo nevracení paměti.

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

Důležité

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

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

Pole staticMainPage.Instance umožňuje MainPage.NavigateToNoteEntryPage vyvolání metody, která je znázorněna 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 UPW se obvykle provádí s metodou Frame.NavigatePage , která přebírá argument. Xamarin.Forms definuje rozšiřující metodu Frame.NavigateContentPage, která přebírá instanci odvozené stránky. Proto se při NavigateToNoteEntryPage spuštění metody zobrazí uživatelské rozhraní definované v sadě Xamarin.FormsNoteEntryPage , jak je znázorněno na následujícím snímku obrazovky:

NoteEntryPage Po zobrazení se klepnutím na šipku zpět zobrazí FrameworkElement šipka pro NoteEntryPage návrat ze zásobníku v aplikaci zpět a vrátí uživatele do FrameworkElementNotesPage třídy.

Povolení podpory změny velikosti stránky

Při změně velikosti Xamarin.Forms okna aplikace pro UPW by se měl také změnit velikost obsahu. Toho se dosahuje registrací obslužné rutiny události pro Loaded událost v konstruktoru MainPage :

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

Událost Loaded se aktivuje, když je stránka rozložena, vykreslena a připravena k interakci, a spustí metodu OnMainPageLoaded v odpovědi:

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

Metoda OnMainPageLoaded zaregistruje anonymní obslužnou rutinu Frame.SizeChanged události pro událost, která je vyvolána buď při ActualHeight změně ActualWidth vlastností v objektu Frame. V odpovědi Xamarin.Forms se změní velikost obsahu aktivní stránky voláním Layout metody.

V UPW musí aplikace povolit zpět navigaci pro všechna tlačítka pro zpětný hardware a software napříč různými faktory formulářů zařízení. Toho lze dosáhnout registrací obslužné rutiny události pro BackRequested událost, kterou lze provést v konstruktoru MainPage :

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

Při spuštění aplikace metoda GetForCurrentView načte SystemNavigationManager objekt přidružený k aktuálnímu zobrazení a pak zaregistruje obslužnou rutinu BackRequested události pro událost. Aplikace obdrží tuto událost pouze v případě, že se jedná o aplikaci na popředí, a v odpovědi volá obslužnou rutinu OnBackRequested 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;
    }
}

Obslužná rutina OnBackRequested události volá metodu GoBack v kořenovém rámci aplikace a nastaví BackRequestedEventArgs.Handled vlastnost tak, aby true označovala událost jako zpracována. Selhání označení události jako zpracovávané může vést k ignorování události.

Aplikace zvolí, jestli se má na záhlaví zobrazit tlačítko Zpět. Toho dosáhnete nastavením AppViewBackButtonVisibility vlastnosti na jednu z hodnot výčtu AppViewBackButtonVisibility ve App třídě:

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

Obslužná rutina OnNavigated události, která se spustí v reakci na Navigated aktivaci události, aktualizuje viditelnost tlačítka zpět záhlaví při navigaci na stránce. Tím se zajistí, že se tlačítko Zpět záhlaví zobrazí, pokud zásobník back v aplikaci není prázdný nebo se odebere z záhlaví, pokud je zásobník back v aplikaci prázdný.

Další informace o podpoře zpětné navigace v UPW najdete v historii navigace a zpětné navigaci pro aplikace pro UPW.

Nativní zobrazení

Xamarin.Forms v nativních projektech Xamarinu

iOS

Android

Povolení podpory zpětné navigace

Více aktivit

Zvolit soubor

UWP

Povolení podpory změny velikosti stránky

Povolení podpory zpětné navigace

Další materiály

Xamarin.Forms v nativních projektech Xamarinu

iOS

Android

Povolení podpory zpětné navigace

Více aktivit

Zvolit soubor

UWP

Povolení podpory změny velikosti stránky

Povolení podpory zpětné navigace

Související odkazy

Další materiály