Návod: Vytvoření vazby knihovny iOS Swift

Článek
02/07/2024

Důležité

V současné době prošetřujeme využití vlastních vazeb na platformě Xamarin. Pokud chcete informovat budoucí úsilí o rozvoj, využijte tento průzkum .

Xamarin umožňuje vývojářům mobilních aplikací vytvářet nativní mobilní prostředí pro různé platformy pomocí sady Visual Studio a jazyka C#. Můžete použít komponenty sady SDK platformy pro iOS. V mnoha případech ale také chcete používat sady SDK třetích stran vyvinuté pro danou platformu, které Xamarin umožňuje provádět prostřednictvím vazeb. Pokud chcete do aplikace Xamarin.iOS začlenit architekturu třetí strany Objective-C , musíte pro ni vytvořit vazbu Xamarin.iOS, abyste ji mohli použít ve svých aplikacích.

Platforma pro iOS spolu s nativními jazyky a nástroji se neustále vyvíjí a Swift je jednou z nejvýraznějších oblastí ve vývojovém světě pro iOS. Existuje řada sad SDK třetích stran, které už byly migrovány do Objective-C Swiftu a představují nové výzvy. I když je proces vazby Swift podobný Objective-C, vyžaduje další kroky a nastavení konfigurace k úspěšnému sestavení a spuštění aplikace Xamarin.iOS, která je přijatelná pro AppStore.

Cílem tohoto dokumentu je nastínit obecný přístup k řešení tohoto scénáře a poskytnout podrobný průvodce jednoduchým příkladem.

Pozadí

Společnost Swift byla původně představena společností Apple v roce 2014 a nyní je ve verzi 5.1 s přechodem na architektury třetích stran rychle roste. Máte několik možností pro vazbu rozhraní Swift a tento dokument popisuje přístup pomocí Objective-C vygenerované hlavičky rozhraní. Hlavičku automaticky vytvoří nástroje Xcode při vytváření architektury a slouží jako způsob komunikace ze spravovaného světa do světa Swiftu.

Požadavky

K dokončení tohoto návodu potřebujete:

Xcode
Visual Studio pro Mac
Objective Sharpie
Rozhraní příkazového řádku AppCenter (volitelné)

Vytvoření nativní knihovny

Prvním krokem je sestavení nativního rozhraní Swift Framework s Objective-C povolenou hlavičkou. Rozhraní obvykle poskytuje vývojář třetí strany a má hlavičku vloženou do balíčku v následujícím adresáři: FrameworkName.framework>/Headers/<FrameworkName-Swift.h>.<

Tato hlavička zveřejňuje veřejná rozhraní, která se použijí k vytvoření metadat vazeb Xamarin.iOS a vygenerují třídy jazyka C#, které zpřístupňují členy architektury Swift. Pokud záhlaví neexistuje nebo obsahuje neúplné veřejné rozhraní (například nevidíte třídy nebo členy), máte dvě možnosti:

Aktualizace zdrojového kódu Swiftu pro vygenerování hlavičky a označení požadovaných členů atributem @objc
Sestavení proxy architektury, kde řídíte veřejné rozhraní a proxy všechna volání základní architektury

V tomto kurzu se druhý přístup popisuje, protože má méně závislostí na zdrojovém kódu třetí strany, který není vždy k dispozici. Dalším důvodem, proč se vyhnout prvnímu přístupu, je další úsilí potřebné k podpoře budoucích změn architektury. Jakmile začnete přidávat změny do zdrojového kódu třetí strany, zodpovídáte za podporu těchto změn a jejich potenciální sloučení s každou budoucí aktualizací.

V tomto kurzu se například vytvoří vazba sady Gigya Swift SDK :

Otevřete Xcode a vytvořte novou architekturu Swift, která bude proxy serverem mezi kódem Xamarin.iOS a architekturou Swift třetích stran. Klikněte na Soubor > nový > projekt a postupujte podle pokynů průvodce:
Stáhněte si Gigya xcframework z webu pro vývojáře a rozbalte ho. V době psaní tohoto článku je nejnovější verze Gigya Swift SDK 1.5.3
V Průzkumníku souborů projektu vyberte SwiftFrameworkProxy a pak vyberte kartu Obecné.
Přetáhněte balíček Gigya.xcframework do seznamu Xcode Frameworks a knihovny na kartě Obecné, zaškrtněte při přidávání architektury možnost Kopírovat položky v případě potřeby:

Ověřte, že se do projektu přidala architektura Swiftu, jinak nebudou k dispozici následující možnosti.
Ujistěte se, že je vybraná možnost Neskládat , která bude později řízena ručně:
Ujistěte se, že možnost Sestavení Nastavení možnost Always Embed Swift Standard Libraries, která obsahuje knihovny Swiftu s architekturou, je nastavená na Ne. Později bude ručně řízen, které knihovny Swift dylib jsou zahrnuty do konečného balíčku:
Ujistěte se, že je možnost Povolit bitcode nastavená na Ne. Odteď Xamarin.iOS nezahrnuje Bitcode, zatímco Apple vyžaduje, aby všechny knihovny podporovaly stejné architektury:

Spuštěním následujícího příkazu terminálu v rámci rozhraní můžete ověřit, že výsledná architektura má zakázanou možnost Bitcode:
```
otool -l SwiftFrameworkProxy.framework/SwiftFrameworkProxy | grep __LLVM
```
Výstup by měl být prázdný, jinak chcete zkontrolovat nastavení projektu pro vaši konkrétní konfiguraci.
Ujistěte se, že je povolená Objective-C možnost Generated interface Header Name (Název záhlaví vygenerovaného rozhraní) a určuje název hlavičky. Výchozí název je FrameworkName-Swift.h>:<

Tip

Pokud tato možnost není dostupná, nejprve se ujistěte, že do projektu přidáte .swift soubor, jak je vysvětleno níže, a pak se vraťte k Build Settings nastavení, které by mělo být zjistitelné.
Zpřístupněte požadované metody a označte je atributem @objc a použijte další pravidla definovaná níže. Pokud vytvoříte architekturu bez tohoto kroku, vygenerovaná Objective-C hlavička bude prázdná a Xamarin.iOS nebude mít přístup k členům architektury Swift. Zveřejnění logiky inicializace pro podkladovou sadu Gigya Swift SDK vytvořením nového souboru SwiftFrameworkProxy.swift a definováním následujícího kódu:
```
import Foundation
import UIKit
import Gigya

@objc(SwiftFrameworkProxy)
public class SwiftFrameworkProxy : NSObject {

    @objc
    public func initFor(apiKey: String) -> String {
        Gigya.sharedInstance().initFor(apiKey: apiKey)
        let gigyaDomain = Gigya.sharedInstance().config.apiDomain
        let result = "Gigya initialized with domain: \(gigyaDomain)"
        return result
    }
}
```
Několik důležitých poznámek k výše uvedenému kódu:
- Gigya Import modulu sem z původní sady Gigya SDK třetích stran umožňuje přístup k libovolnému členu rozhraní.
- Mark SwiftFrameworkProxy třída s @objc atributem určujícím název, jinak se vygeneruje jedinečný nečitelný název, například _TtC19SwiftFrameworkProxy19SwiftFrameworkProxy. Název typu by měl být jasně definovaný, protože ho později použije jeho název.
- Zdědí třídu proxy, NSObjectjinak se v Objective-C souboru hlavičky negeneruje.
- Označte všechny členy, které mají být vystaveny jako public.
Změňte konfiguraci sestavení schématu z ladění na verzi. Chcete-li to provést, otevřete dialogové okno Xcode > Target > Edit Scheme a pak nastavte možnost Konfigurace sestavení na Release:

V tuto chvíli je architektura připravená k vytvoření. Sestavte architekturu pro architekturu simulátoru i zařízení a pak zkombinujte výstupy jako jednu sadu binární architektury (.xcframework). Sestavení spusťte pomocí následujících příkazů:

xcodebuild -project "Swift/SwiftFrameworkProxy/SwiftFrameworkProxy.xcodeproj" archive \
  -scheme "SwiftFrameworkProxy" \
  -configuration Release \
  -archivePath "build/SwiftFrameworkProxy-simulator.xcarchive" \
  -destination "generic/platform=iOS Simulator" \
  -derivedDataPath "build" \
  -IDECustomBuildProductsPath="" -IDECustomBuildIntermediatesPath="" \
  ENABLE_BITCODE=NO \
  SKIP_INSTALL=NO \
  BUILD_LIBRARY_FOR_DISTRIBUTION=YES

 xcodebuild -project "Swift/SwiftFrameworkProxy/SwiftFrameworkProxy.xcodeproj" archive \
   -scheme "SwiftFrameworkProxy" \
   -configuration Release \
   -archivePath "build/SwiftFrameworkProxy-ios.xcarchive" \
   -destination "generic/platform=iOS" \
   -derivedDataPath "build" \
   -IDECustomBuildProductsPath="" -IDECustomBuildIntermediatesPath="" \
   ENABLE_BITCODE=NO \
   SKIP_INSTALL=NO \
   BUILD_LIBRARY_FOR_DISTRIBUTION=YES

Tip

Další informace o vytváření binárních architektur

Tip

Pokud místo projektu máte pracovní prostor, sestavte pracovní prostor a jako povinný parametr zadejte cíl. Chcete také zadat výstupní adresář, protože pro pracovní prostory se tento adresář bude lišit od sestavení projektu.

Tip

Pomocí pomocného skriptu můžete také sestavit architekturu pro všechny příslušné architektury nebo ji jednoduše sestavit z přepínače Simulátor xcode a zařízení v cílovém selektoru.

Existují dva archivy s vygenerovanými architekturami, jeden pro každou platformu, zkombinujte je jako jednu sadu binárních architektur, která se později vloží do projektu vazby Xamarin.iOS. Pokud chcete vytvořit sadu binární architektury, která kombinuje obě architektury, musíte provést následující kroky. Balíček .xcarchive je jen složka, takže můžete provádět všechny typy operací, jako je přidávání, odebírání a nahrazování souborů:
- Vytvořte v xcframework archivech architekturu s předchozími integrovanými architekturami:
```
xcodebuild -create-xcframework \
  	-framework "build/SwiftFrameworkProxy-simulator.xcarchive/Products/Library/Frameworks/SwiftFrameworkProxy.framework" \
  	-framework "build/SwiftFrameworkProxy-ios.xcarchive/Products/Library/Frameworks/SwiftFrameworkProxy.framework" \
  	-output "build/SwiftFrameworkProxy.xcframework"
```
Tip

Pokud chcete podporovat jenom jednu platformu (například vytváříte aplikaci, která se dá spustit jenom na zařízení), můžete tento krok přeskočit k vytvoření knihovny .xcframework a použití výstupní architektury z sestavení zařízení dříve.

Tip

Pomocí pomocného skriptu můžete také vytvořit .xcframework, který automatizuje všechny výše uvedené kroky.

Příprava metadat

V tuto chvíli byste měli mít .xcframework s Objective-C vygenerovanou hlavičkou rozhraní připravenou k použití vazbou Xamarin.iOS. Dalším krokem je příprava rozhraní API pro definice, která jsou používána projektem vazby ke generování tříd jazyka C#. Tyto definice lze vytvořit ručně nebo automaticky nástrojem Objective Sharpie a vygenerovaným souborem hlaviček. K vygenerování metadat použijte Sharpie:

Stáhněte si nejnovější nástroj Objective Sharpie z oficiálního webu ke stažení a nainstalujte ho podle průvodce. Po dokončení instalace ji můžete ověřit spuštěním příkazu sharpie:
```
sharpie -v
```
Generovat metadata pomocí sharpie a automaticky vygenerovaného Objective-C souboru hlaviček:
```
sharpie bind --sdk=iphoneos16.4 --output="XamarinApiDef" --namespace="Binding" --scope="build/SwiftFrameworkProxy.xcframework/ios-arm64/SwiftFrameworkProxy.framework/Headers/" "build/SwiftFrameworkProxy.xcframework/ios-arm64/SwiftFrameworkProxy.framework/Headers/SwiftFrameworkProxy-Swift.h"
```
Výstup odráží vygenerovaný soubor metadat: ApiDefinitions.cs. Uložte tento soubor, abyste ho mohli zahrnout do projektu vazeb Xamarin.iOS spolu s nativními odkazy:
```
Parsing 1 header files...
Binding...
    [write] ApiDefinitions.cs
```
Nástroj vygeneruje metadata jazyka C# pro každého vystaveného Objective-C člena, který bude vypadat podobně jako následující kód. Jak vidíte, je možné ho definovat ručně, protože má čitelný formát a přímé mapování členů:
```
[Export ("initForApiKey:")]
string InitForApiKey (string apiKey);
```
Tip

Název souboru záhlaví se může lišit, pokud jste změnili výchozí nastavení Xcode pro název záhlaví. Ve výchozím nastavení má název projektu s příponou -Swift . Soubor a jeho název můžete kdykoli zkontrolovat tak, že přejdete do složky záhlaví balíčku architektury.

Tip

Jako součást procesu automatizace můžete použít pomocný skript k automatickému vygenerování metadat po vytvoření prvku .xcframework.

Vytvoření knihovny vazeb

Dalším krokem je vytvoření projektu vazby Xamarin.iOS pomocí šablony vazeb sady Visual Studio, přidání požadovaných metadat, nativních odkazů a následné sestavení projektu pro vytvoření spotřební knihovny:

Otevřete Visual Studio pro Mac a vytvořte nový projekt knihovny vazeb Xamarin.iOS, pojmenujte ho v tomto případě SwiftFrameworkProxy.Binding a dokončete průvodce. Šablona vazby Xamarin.iOS se nachází v následující cestě: Knihovna vazeb knihovny > pro iOS>:
Odstraňte existující soubor metadat ApiDefinition.cs , protože bude zcela nahrazen metadaty vygenerovaným nástrojem Objective Sharpie.
Zkopírujte metadata vygenerovaná Sharpie v jednom z předchozích kroků, vyberte v okně vlastností následující akci sestavení: ObjBindingApiDefinition pro soubor ApiDefinitions.cs a ObjBindingCoreSource pro soubor StructsAndEnums.cs :

Samotná metadata popisují každou vystavenou Objective-C třídu a člena pomocí jazyka C#. Kromě deklarace jazyka C# uvidíte i původní Objective-C definici hlavičky:
```
// @interface SwiftFrameworkProxy : NSObject
[BaseType (typeof(NSObject))]
interface SwiftFrameworkProxy
{
    // -(NSString * _Nonnull)initForApiKey:(NSString * _Nonnull)apiKey __attribute__((objc_method_family("none"))) __attribute__((warn_unused_result));
    [Export ("initForApiKey:")]
    string InitForApiKey (string apiKey);
}
```
I když se jedná o platný kód jazyka C#, nepoužívá se tak, jak je, ale používá nástroje Xamarin.iOS k vygenerování tříd jazyka C# na základě této definice metadat. Výsledkem je, že místo rozhraní SwiftFrameworkProxy získáte třídu jazyka C# se stejným názvem, která se dá vytvořit instancí kódu Xamarin.iOS. Tato třída získává metody, vlastnosti a další členy definované vašimi metadaty, které budete volat způsobem jazyka C#.
Přidejte nativní odkaz na dříve vygenerovanou sadu binární architektury a také každou závislost této architektury. V tomto případě přidejte nativní odkazy na architekturu SwiftFrameworkProxy i Gigya do vazbového projektu:
- Pokud chcete přidat nativní odkazy na architekturu, otevřete finder a přejděte do složky s architekturami. Přetáhněte architektury pod umístěním Nativní odkazy v Průzkumník řešení. Případně můžete použít možnost místní nabídky ve složce Nativní odkazy a kliknutím na Přidat nativní odkaz vyhledat architektury a přidat je:
- Aktualizujte vlastnosti každého nativního odkazu a zkontrolujte tři důležité možnosti:
  - Nastavit inteligentní odkaz = true
  - Nastavit vynucené načtení = false
  - Nastavte seznam rozhraní použitých k vytvoření původních architektur. V tomto případě má každá architektura pouze dvě závislosti: Foundation a UIKit. Nastavte ho na pole Frameworks:
  Pokud chcete zadat nějaké další příznaky linkeru, nastavte je v poli příznaky linkeru. V takovém případě ponechte prázdnou.
- V případě potřeby zadejte další příznaky linkeru. Pokud knihovna, kterou navazujete, zveřejňuje pouze Objective-C rozhraní API, ale interně používá Swift, může se zobrazit například tyto problémy:
```
error MT5209 : Native linking error : warning: Auto-Linking library not found for -lswiftCore
error MT5209 : Native linking error : warning: Auto-Linking library not found for -lswiftQuartzCore
error MT5209 : Native linking error : warning: Auto-Linking library not found for -lswiftCoreImage
```
  Ve vlastnostech projektu vazby pro nativní knihovnu musí být do příznaků linkeru přidány následující hodnoty:
```
L/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/ -L/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos -Wl,-rpath -Wl,@executable_path/Frameworks
```
  První dvě možnosti (ty -L ... ) říkají nativnímu kompilátoru, kde najít knihovny Swift. Nativní kompilátor bude ignorovat knihovny, které nemají správnou architekturu, což znamená, že je možné předat umístění pro knihovny simulátoru i knihovny zařízení současně, takže funguje pro simulátor i sestavení zařízení (tyto cesty jsou správné jenom pro iOS, pro tvOS a watchOS, které je potřeba aktualizovat). Nevýhodou je, že tento přístup vyžaduje, aby správný kód Xcode byl v /Application/Xcode.app, pokud má uživatel knihovny vazeb Xcode v jiném umístění, nebude fungovat. Alternativním řešením je přidat tyto možnosti do dalších argumentů mtouch v možnostech sestavení iOS spustitelného projektu (--gcc_flags -L... -L...). Třetí možností je, že nativní linker uloží umístění rychlých knihoven ve spustitelném souboru, aby je operační systém mohl najít.
Poslední akcí je sestavení knihovny a ujistěte se, že nemáte žádné chyby kompilace. Často zjistíte, že vazby metadat vytvořené Objective Sharpie budou anotovány atributem [Verify] . Tyto atributy označují, že byste měli ověřit, že Objective Sharpie udělal správnou věc porovnáním vazby s původní Objective-C deklaraci (která bude poskytnuta v komentáři nad vázanou deklaraci). Další informace o členech označených atributem najdete na následujícím odkazu. Jakmile je projekt sestavený, může ho využívat aplikace Xamarin.iOS.

Využití knihovny vazeb

Posledním krokem je využití knihovny vazeb Xamarin.iOS v aplikaci Xamarin.iOS. Vytvořte nový projekt Xamarin.iOS, přidejte odkaz na knihovnu vazeb a aktivujte sadu Gigya Swift SDK:

Vytvořte projekt Xamarin.iOS. Aplikaci pro jedno zobrazení pro iOS >> můžete použít jako výchozí bod:
Přidejte odkaz na projekt vazby do cílového projektu nebo .dll vytvořené dříve. Považovat knihovnu vazeb za běžnou knihovnu Xamarin.iOS:

Aktualizujte zdrojový kód aplikace a přidejte logiku inicializace do primárního ViewControlleru, který aktivuje sadu Gigya SDK.

public override void ViewDidLoad()
{
    base.ViewDidLoad();
    var proxy = new SwiftFrameworkProxy();
    var result = proxy.InitForApiKey("APIKey");
    System.Diagnostics.Debug.WriteLine(result);
}

Vytvořte tlačítko s názvem btnLogin a přidejte následující tlačítko kliknutím na obslužnou rutinu pro aktivaci toku ověřování:

private void btnLogin_Tap(object sender, EventArgs e)
{
    _proxy.LoginWithProvider(GigyaSocialProvidersProxy.Instagram, this, (result, error) =>
    {
        // process your login result here
    });
}

Spusťte aplikaci, ve výstupu ladění by se měl zobrazit následující řádek: Gigya initialized with domain: us1.gigya.com. Kliknutím na tlačítko aktivujte tok ověřování:

Gratulujeme! Úspěšně jste vytvořili aplikaci Xamarin.iOS a knihovnu vazeb, která využívá architekturu Swift. Výše uvedená aplikace se úspěšně spustí na iOSu 12.2 nebo novějším, protože od této verze iOS apple zavedla stabilitu ABI a každý iOS počínaje verzí 12.2+ obsahuje knihovny modulu runtime Swift, které se dají použít ke spuštění vaší aplikace zkompilované pomocí Swiftu 5.1+. Pokud potřebujete přidat podporu starších verzí iOSu, můžete provést několik dalších kroků:

Pokud chcete přidat podporu pro iOS 12.1 a starší, chcete odeslat specifické knihovny Swift dylibs používané ke kompilaci architektury. Pomocí balíčku NuGet Xamarin.iOS.SwiftRuntimeSupport nuGet můžete zpracovat a zkopírovat požadované knihovny s vaší IPA. Přidejte odkaz NuGet do cílového projektu a znovu sestavte aplikaci. Nevyžaduje se žádné další kroky, balíček NuGet nainstaluje konkrétní úlohy, které se spouštějí v procesu sestavení, identifikují požadované knihovny Swift dylib a zabalí je s konečnou IPA.
Pokud chcete aplikaci odeslat do app Storu, chcete použít Xcode a distribuovat možnost, která aktualizuje soubor IPA a složku SwiftSupport , aby ji přijal AppStore:

Ø Archivujte aplikaci. V nabídce Visual Studio pro Mac vyberte Vytvořit > archiv pro publikování:

Tato akce sestaví projekt a dosáhne ho organizátorovi, který je přístupný pomocí Xcode pro distribuci.

Distribuce prostřednictvím Xcode. Otevřete Xcode a přejděte na možnost nabídky Organizátor okna>:

Vyberte archiv vytvořený v předchozím kroku a klikněte na tlačítko Distribuovat aplikaci. Podle pokynů průvodce nahrajte aplikaci do AppStore.
Tento krok je volitelný, ale je důležité ověřit, že vaše aplikace může běžet v iOSu 12.1 a starším i ve verzi 12.2. Můžete to udělat pomocí testovacího cloudu a architektury UITest. Vytvořte projekt UITest a základní test uživatelského rozhraní, který spustí aplikaci:
- Vytvořte projekt UITest a nakonfigurujte ho pro aplikaci Xamarin.iOS:
  
  Tip
  
  Další informace o tom, jak vytvořit projekt UITest a nakonfigurovat ho pro vaši aplikaci, najdete na následujícím odkazu.
- Vytvořte základní test pro spuštění aplikace a použijte některé funkce sady Swift SDK. Tento test aktivuje aplikaci, pokusí se přihlásit a pak stiskne tlačítko Zrušit:
```
[Test]
public void HappyPath()
{
    app.WaitForElement(StatusLabel);
    app.WaitForElement(LoginButton);
    app.Screenshot("App loaded.");
    Assert.AreEqual(app.Query(StatusLabel).FirstOrDefault().Text, "Gigya initialized with domain: us1.gigya.com");

    app.Tap(LoginButton);
    app.WaitForElement(GigyaWebView);
    app.Screenshot("Login activated.");

    app.Tap(CancelButton);
    app.WaitForElement(LoginButton);
    app.Screenshot("Login cancelled.");
}
```
  Tip
  
  Další informace o rozhraní UITests a model UI Automation najdete na následujícím odkazu.
- Vytvořte aplikaci pro iOS v App Center, vytvořte nové testovací spuštění s novou sadou zařízení pro spuštění testu:
  
  Tip
  
  Další informace o AppCenter Test Cloudu najdete na následujícím odkazu.
- Instalace rozhraní příkazového řádku appcenter
```
npm install -g appcenter-cli
```
  Důležité
  
  Ujistěte se, že máte nainstalovaný uzel v6.3 nebo novější.
- Spusťte test pomocí následujícího příkazu. Ujistěte se také, že je příkazový řádek appcenter aktuálně přihlášený.
```
appcenter test run uitest --app "Mobile-Customer-Advisory-Team/SwiftBinding.iOS" --devices a7e7cb50 --app-path "Xamarin.SingleView.ipa" --test-series "master" --locale "en_US" --build-dir "Xamarin/Xamarin.SingleView.UITests/bin/Debug/"
```
- Ověřte výsledek. Na portálu AppCenter přejděte do testovacího testu > aplikace>:
  
  A vyberte požadované testovací spuštění a ověřte výsledek:

Vytvořili jste základní aplikaci Xamarin.iOS, která používá nativní architekturu Swift prostřednictvím knihovny vazeb Xamarin.iOS. Příklad poskytuje zjednodušený způsob, jak použít vybranou architekturu a v reálné aplikaci, budete muset zpřístupnit více rozhraní API a připravit metadata pro tato rozhraní API. Skript pro generování metadat zjednoduší budoucí změny rozhraní API architektury.

Sdílet prostřednictvím

Návod: Vytvoření vazby knihovny iOS Swift

Pozadí

Požadavky

Vytvoření nativní knihovny

Příprava metadat

Vytvoření knihovny vazeb

Využití knihovny vazeb

Další materiály

Sdílet prostřednictvím

Návod: Vytvoření vazby knihovny iOS Swift

Pozadí

Požadavky

Vytvoření nativní knihovny

Příprava metadat

Vytvoření knihovny vazeb

Využití knihovny vazeb

Související odkazy

Další materiály