Návod: vytvoření vazby Objective-C knihovny iOS

Tento článek poskytuje praktický návod k vytvoření vazby Xamarin. iOS pro existující Objective-C knihovnu InfColorPicker. Zahrnuje témata, jako je kompilace statické Objective-C knihovny, její vazba a použití vazby v aplikaci Xamarin. iOS.

Při práci na iOS se můžou setkat s případy, kdy chcete využívat knihovnu třetí strany Objective-C . v těchto situacích můžete použít Project vazby Xamarin. iOS k vytvoření vazby jazyka C# , která vám umožní využít knihovnu v aplikacích Xamarin. ios.

Obecně v ekosystému iOS můžete knihovny najít ve třech charakterech:

• Jako předkompilovaný statický soubor knihovny s .a příponou společně s jeho hlavičkami (soubory. h). Například Analytická knihovna Google
• Jako Předkompilovaná architektura. Toto je pouze složka obsahující statickou knihovnu, hlavičky a někdy další prostředky s .framework příponou. Například Knihovna Google AdMob.
• Jako pouze soubory zdrojového kódu. Například knihovna obsahující pouze .m.h soubory a cíle jazyka C.

V prvním a druhém scénáři už bude Předkompilovaná CocoaTouch Statická knihovna, takže v tomto článku se zaměříme na třetí scénář. Nezapomeňte, že předtím, než začnete vytvářet vazbu, si vždy Projděte licenci poskytovanou knihovnou, abyste měli jistotu, že ji můžete svázat.

Tento článek poskytuje podrobný návod, jak vytvořit projekt vazby pomocí Open source projektu InfColorPicker jako příklad, ale všechny informace v této příručce je možné přizpůsobit pro použití s jakoukoli Objective-C knihovnou třetích stran. Knihovna InfColorPicker poskytuje opakovaně použitelný kontroler zobrazení, který umožňuje uživateli vybrat barvu založenou na jeho znázornění v HSB, takže výběr barev je uživatelsky přívětivější.

Pokryjeme všechny nezbytné kroky pro využívání tohoto konkrétního Objective-C rozhraní API v Xamarin. iOS:

• Nejprve vytvoříme Objective-C statickou knihovnu pomocí Xcode.
• Pak navážete tuto statickou knihovnu pomocí Xamarin. iOS.
• Dále si ukážeme, jak může objektivní ostrost snížit zatížení tím, že automaticky generuje některé (ale ne všechny) potřebné definice rozhraní API, které vyžaduje vazba Xamarin. iOS.
• Nakonec vytvoříme aplikaci Xamarin. iOS, která používá vazbu.

Ukázková aplikace vám ukáže, jak používat silný delegáta pro komunikaci mezi rozhraním API InfColorPicker a kódem v jazyce C#. Po zobrazení způsobu použití silného delegáta si ukážeme, jak používat slabé delegáty k provádění stejných úkolů.

Požadavky

V tomto článku se předpokládá, že máte zkušenosti s Xcode a Objective-C jazykem a jste si přečetli naši Binding Objective-C dokumentaci. K provedení těchto kroků se navíc vyžaduje následující:

• Xcode a iOS SDK – Apple Xcode a nejnovější rozhraní API pro iOS musí být nainstalované a nakonfigurované v počítači vývojáře.
• Nástroje příkazového řádku Xcode – pro aktuálně nainstalovanou verzi Xcode musí být nainstalované nástroje příkazového řádku Xcode (podrobnosti o instalaci najdete níže).
• Visual Studio pro Mac nebo Visual Studio – na vývojovém počítači by měla být nainstalovaná a nakonfigurovaná nejnovější verze Visual Studio pro Mac nebo Visual Studio. pro vývoj aplikace xamarin. ios je vyžadován Apple Mac a při použití Visual Studio musíte být připojeni k hostiteli sestavení xamarin. ios.
• Nejnovější verze objektivního cíle – aktuální kopie nástroje pro účelovou ostrost, kterou si stáhnete z tohoto místa. Pokud už máte nainstalovanou cílovou ostrost, můžete ji aktualizovat na nejnovější verzi pomocí sharpie update

Instalace nástrojů příkazového řádku Xcode

V závislosti na sestavování společnosti Apple z příkazového řádku s Xcode nejčastějšími dotazy v operačním systému X 10,9 a vyšším se v podokně soubory ke stažení dialogového okna Předvolby Xcode už nepodporuje stahování nástrojů příkazového řádku.

K instalaci těchto nástrojů budete muset použít jednu z následujících metod:

• Instalace Xcode – při instalaci Xcode je součástí balíčku všechny nástroje příkazového řádku. V překrytí OS X 10,9 (instalovaných v nástroji /usr/bin ) lze namapovat libovolný nástroj, /usr/bin který je součástí nástroje, na odpovídající nástroj v Xcode. Například xcrun příkaz, který umožňuje najít nebo spustit libovolný nástroj v rámci Xcode z příkazového řádku.

• Terminálová aplikace – z aplikace terminálu můžete nainstalovat nástroje příkazového řádku spuštěním příkazu:

  • Spusťte aplikaci Terminal.
  • Zadejte xcode-select --install a stiskněte klávesu xcode-select --install, například:

  Europa:~ kmullins$ xcode-select --install
  

  • Zobrazí se výzva k instalaci nástrojů příkazového řádku, klikněte na tlačítko nainstalovat : .

  • Nástroje se stáhnou a nainstalují ze serverů společnosti Apple:

• Soubory ke stažení pro vývojáře Apple – balíček nástrojů příkazového řádku je k dispozici na webové stránce soubory ke stažení pro vývojáře Apple . Přihlaste se pomocí Apple ID, vyhledejte a Stáhněte si nástroje příkazového řádku: .

V nainstalovaných nástrojích příkazového řádku jsme připraveni k pokračování v postupu.

Názorný postup

V tomto návodu pokryjeme tyto kroky:

• Vytvoření statické knihovny – tento krok zahrnuje vytvoření statické knihovny kódu InfColorPicker . Statická knihovna bude mít .a příponu souboru a bude vložena do sestavení .NET projektu knihovny.
• vytvoření vazby xamarin. ios Project – jakmile máme statickou knihovnu, použijeme ji k vytvoření projektu vazby xamarin. ios. Projekt vazby se skládá ze statické knihovny, kterou jsme právě vytvořili, a metadat ve formě kódu jazyka C#, který vysvětluje, jak Objective-C lze rozhraní API použít. Tato metadata se běžně označují jako definice rozhraní API. K vytvoření definic rozhraní API budeme používat objektivní ostrost .
• Normalizujte definice rozhraní API – ostrost objektivně zajišťuje skvělou úlohu, která nám pomáhá, ale nedokáže všechno dělat. Než bude možné tyto definice rozhraní API použít, probereme několik změn, které potřebujeme udělat.
• Použijte knihovnu vazeb – nakonec vytvoříme aplikaci Xamarin. iOS, která ukazuje, jak používat náš nově vytvořený projekt vazby.

Teď, když rozumíte tomu, jaké kroky jsou součástí, pojďme přejít na zbytek tohoto návodu.

Vytvoření statické knihovny

Pokud zkontrolujeme kód pro InfColorPicker v GitHubu:

V projektu můžeme zobrazit následující tři adresáře:

• InfColorPicker – tento adresář obsahuje kód pro projekt.
• PickerSamplePad – tento adresář obsahuje ukázkový projekt iPad.
• PickerSamplePhone – tento adresář obsahuje ukázkový projekt iPhone.

pojďme si stáhnout projekt InfColorPicker z GitHub a rozbalit ho v adresáři našeho výběru. Otevřením cíle Xcode pro PickerSamplePhone projekt se v Navigátoru Xcode zobrazí následující struktura projektu:

Tento projekt dosahuje opakovaného použití kódu přímým přidáním zdrojového kódu InfColorPicker (do červeného pole) do každého ukázkového projektu. Kód ukázkového projektu je v modrém poli. Vzhledem k tomu, že tento konkrétní projekt neposkytuje se statickou knihovnou, je nutné, aby nám vytvořil projekt Xcode ke kompilaci statické knihovny.

Prvním krokem je, abychom přidali zdrojový kód InfoColorPicker do statické knihovny. Abychom to dosáhli, udělejte toto:

1. Spusťte Xcode.

2. v nabídce soubor vyberte novýProject...:

   

3. Vyberte možnost Knihovna rozhraní, Statická knihovna pro Kakaové Touch a klikněte na tlačítko Další :

   

4. jako InfColorPickerInfColorPicker zadejte a klikněte na tlačítko další :

   

5. Vyberte umístění, kam chcete projekt uložit, a klikněte na tlačítko OK .

6. Nyní potřebujeme přidat zdroj z projektu InfColorPicker do našeho projektu statických knihoven. Vzhledem k tomu, že soubor InfColorPicker. h již existuje v naší statické knihovně (ve výchozím nastavení), Xcode ho nebude moci přepsat. ve vyhledávačipřejděte do zdrojového kódu InfColorPicker v původním projektu, který vrátíme z GitHub, zkopírujte všechny soubory InfColorPicker a vložte je do našeho nového projektu statické knihovny:

   

7. Vraťte se do Xcode, klikněte pravým tlačítkem na složku InfColorPicker a vyberte Add files to InfColorPicker... (Přidat soubory do InfColorPickeru...):

   

8. V dialogovém okně Přidat soubory přejděte k souborům zdrojového kódu InfColorPicker, které jsme právě zkopírili, vyberte je všechny a klikněte na tlačítko Přidat:

   

9. Zdrojový kód se zkopíruje do našeho projektu:

   

10. V okně Xcode Project Navigator vyberte soubor InfColorPicker.m a okomentování posledních dvou řádků (kvůli způsobu, jakým byla tato knihovna napsána, se tento soubor nebude používat):

    

11. Teď musíme zkontrolovat, jestli knihovna vyžaduje nějaká rozhraní. Tyto informace najdete buď v souboru README, nebo otevřením jednoho z poskytnutých ukázkových projektů. V tomto Foundation.framework příkladu UIKit.framework se používají , a , takže je CoreGraphics.framework přidáme.

12. Vyberte fáze sestavení cíle InfColorPicker a rozbalte část Propojení binárního souboru s knihovnami:

    

13. Pomocí tlačítka otevřete dialogové okno, ve které můžete přidat požadovaná rozhraní + rámců uvedená výše:

    

14. Část Link Binary With Libraries (Propojení binárního souboru s knihovnami) by teď měla vypadat jako na následujícím obrázku:

    

V tuto chvíli jsme blízko, ale ještě to není úplně hotové. Statická knihovna byla vytvořena, ale musíme ji sestavit, aby vytvořila binární soubor Fat, který obsahuje všechny požadované architektury pro zařízení s iOSem i simulátor iOS.

Vytvoření binárního souboru s tučným obsahem

Všechna zařízení s iOSem mají procesory využívající architekturu ARM, které se v průběhu času vyvíjely. Každá nová architektura přidala nové pokyny a další vylepšení a současně zachovala zpětnou kompatibilitu. Zařízení s iOSem mají sady instrukcí armv6, armv7, armv7s a arm64, i když armv6 už nepoužíva. Simulátor iOS nepoužít ARM a je to simulátor x86 a x86_64. To znamená, že knihovny musí být k dispozici pro každou sadu instrukcí.

Knihovna Fat je .a soubor obsahující všechny podporované architektury.

Vytvoření tučného binárního souboru je proces se třemi kroky:

• Zkompilujte & statickou knihovnu ve verzi ARM 7 ARM64.
• Zkompilujte verzi x84_64 x86 a statickou knihovnu.
• Pomocí nástroje příkazového řádku tyto dvě statické knihovny zkombinujte lipo do jedné.

I když jsou tyto tři kroky poměrně jednoduché, může být nutné je v budoucnu opakovat, když knihovna obdrží aktualizace nebo pokud Objective-C budeme vyžadovat opravy chyb. Pokud se rozhodnete tyto kroky automatizovat, zjednoduší se budoucí údržba a podpora projektu vazeb pro iOS.

K dispozici je mnoho nástrojů pro automatizaci takových úloh – skript prostředí, rake,xbuilda make. Když jsou nainstalované nástroje příkazového řádku Xcode, nainstaluje se také , takže to je sestavovací systém, který se použije make pro tento názorný postup. Tady je soubor pravidel, který můžete použít k vytvoření sdílené knihovny s více architekturami, která bude fungovat na zařízení s iOSem a simulátoru pro libovolnou knihovnu:

XBUILD=/Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild
PROJECT_ROOT=./YOUR-PROJECT-NAME
PROJECT=$(PROJECT_ROOT)/YOUR-PROJECT-NAME.xcodeproj
TARGET=YOUR-PROJECT-NAME

all: lib$(TARGET).a

lib$(TARGET)-i386.a:
	$(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphonesimulator -configuration Release clean build
	-mv $(PROJECT_ROOT)/build/Release-iphonesimulator/lib$(TARGET).a $@

lib$(TARGET)-armv7.a:
	$(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphoneos -arch armv7 -configuration Release clean build
	-mv $(PROJECT_ROOT)/build/Release-iphoneos/lib$(TARGET).a $@

lib$(TARGET)-arm64.a:
	$(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphoneos -arch arm64 -configuration Release clean build
	-mv $(PROJECT_ROOT)/build/Release-iphoneos/lib$(TARGET).a $@

lib$(TARGET).a: lib$(TARGET)-i386.a lib$(TARGET)-armv7.a lib$(TARGET)-arm64.a
	xcrun -sdk iphoneos lipo -create -output $@ $^

clean:
	-rm -f *.a *.dll

V editoru prostého textu podle vašeho výběru zadejte příkazy Makefile (Soubor pravidel) a aktualizujte oddíly na YOUR-PROJECT-NAME názvem vašeho projektu. Je také důležité zajistit, abyste výše uvedené pokyny vložíme přesně s kartami, které jsou v pokynech zachované.

Uložte soubor s názvem Makefile do stejného umístění jako statická knihovna InfColorPicker Xcode, kterou jsme vytvořili výše:

Otevřete terminálovou aplikaci na počítači Mac a přejděte do umístění souboru pravidel. Do make terminálu zadejte , stiskněte makea spustí se soubor pravidel:

Když spustíte příkaz make, uvidíte, jak se posouvání hodně textu. Pokud vše fungovalo správně, zobrazí se slova BUILD SUCCEEDED (SESTAVENÍ PROBĚHLO ÚSPĚŠNĚ) a soubory a se zkopírují do stejného umístění jako soubor libInfColorPicker-i386.alibInfColorPickerSDK.alibInfColorPicker-i386.a

Architektury v binárním souboru Fat můžete ověřit pomocí následujícího příkazu:

xcrun -sdk iphoneos lipo -info libInfColorPicker.a

Mělo by se zobrazit následující:

Architectures in the fat file: libInfColorPicker.a are: i386 armv7 x86_64 arm64

V tuto chvíli jsme dokončili první krok naší vazby na iOS vytvořením statické knihovny pomocí Xcode a nástrojů příkazového řádku Xcode a makelipo . Přejděte k dalšímu kroku a pomocí Objective-Sharpie automatizujte vytváření vazeb rozhraní API.

Vytvoření vazby Xamarin.iOS Project

Než budeme moci použít Objective-Sharpie k automatizaci procesu vazby, musíme vytvořit vazbu Xamarin.iOS Project pro sestavení definic rozhraní API (které budeme používat Objective-Sharpie, abychom mohli sestavovat) a vytvořit vazbu C# za nás.

Pustíme se do následujících akcí:

• ApiDefinition.cs – Tento soubor bude obsahovat kontrakty, které definují, jak se rozhraní API zabalí do jazyka C#.
• Structs.cs – Tento soubor bude obsahovat všechny struktury nebo výčtové hodnoty, které jsou vyžadovány rozhraními a delegáty.

S těmito dvěma soubory budeme pracovat později v tomto názorném postupu. Nejprve musíme do projektu vazby přidat knihovnu InfColorPicker.

Zahrnutí statické knihovny do vazby Project

Teď máme připravenou základní Project vazby a pro knihovnu InfColorPicker musíme přidat knihovnu Fat Binary, kterou jsme vytvořili výše.

Knihovnu přidáte takto:

Když se do projektu přidá soubor .a, Xamarin.iOS automaticky nastaví akci sestavení souboru na ObjcBindingNativeLibrarya vytvoří speciální soubor s názvem .

Tento soubor obsahuje atribut LinkWith , který říká Xamarin.iOS, jak zpracovat statickou knihovnu, kterou jsme právě přidali. Obsah tohoto souboru je zobrazený v následujícím fragmentu kódu:

using ObjCRuntime;

[assembly: LinkWith ("libInfColorPickerSDK.a", SmartLink = true, ForceLoad = true)]

Atribut LinkWith identifikuje statickou knihovnu projektu a některé důležité příznaky linkeru.

Další věcí, kterou musíme udělat, je vytvoření definic rozhraní API pro projekt InfColorPicker. Pro účely tohoto návodu použijeme Objective Sharpie k vygenerování souboru ApiDefinition.cs.

Použití Objective Sharpie

Začneme tím, že si stáhneme instalační soubor Objective Sharpie podle podrobných informací v tomto průvodci. Spusťte instalační program a podle pokynů na obrazovce průvodce instalací nainstalujte Objective Sharpie na náš vývojový počítač.

Po úspěšné instalaci Objective Sharpie můžeme spustit aplikaci Terminal a zadat následující příkaz, který vám pomůže se všemi nástroji, které poskytuje jako pomoc při vytváření vazeb:

sharpie -help

Pokud spustíme výše uvedený příkaz, vygeneruje se následující výstup:

Europa:Resources kmullins$ sharpie -help
usage: sharpie [OPTIONS] TOOL [TOOL_OPTIONS]

Options:
  -h, --helpShow detailed help
  -v, --versionShow version information

Available Tools:
  xcode              Get information about Xcode installations and available SDKs.
  pod                Create a Xamarin C# binding to Objective-C CocoaPods
  bind               Create a Xamarin C# binding to Objective-C APIs
  update             Update to the latest release of Objective Sharpie
  verify-docs        Show cross reference documentation for [Verify] attributes
  docs               Open the Objective Sharpie online documentation

Pro účely tohoto návodu budeme používat následující nástroje Objective Sharpie:

• xcode – tyto nástroje nám dávají informace o naší aktuální instalaci Xcode a verzích rozhraní API pro iOS a Mac, která jsme nainstalovali. Tyto informace použijeme později při generování vazeb.
• bind – tento nástroj použijeme k parsování souborů .h v projektu InfColorPicker do počátečních souborů ApiDefinition.cs a StructsAndEnums.cs.

Pokud chcete získat nápovědu ke konkrétnímu nástroji Objective Sharpie, zadejte název nástroje a -help možnost. Například vrátí sharpie xcode -help následující výstup:

Europa:Resources kmullins$ sharpie xcode -help
usage: sharpie xcode [OPTIONS]+

Options:
  -h, -help           Show detailed help
  -v, -verbose        Be verbose with output

Xcode Options:
  -sdks               List all available Xcode SDKs. Pass -verbose for more
                        details.
  -sdkpath SDK        Output the path of the SDK
  -frameworks SDK     List all available framework directories in a given SDK.

Než můžeme zahájit proces vazby, potřebujeme získat informace o našich aktuálních nainstalovaných ks zadáním následujícího příkazu do terminálu sharpie xcode -sdks :

amyb:Desktop amyb$ sharpie xcode -sdks
sdk: appletvos9.2    arch: arm64
sdk: iphoneos9.3     arch: arm64   armv7
sdk: macosx10.11     arch: x86_64  i386
sdk: watchos2.2      arch: armv7

Z výše uvedeného můžeme vidět, že na našem počítači máme iphoneos9.3 nainstalovanou sadu SDK. Tyto informace jsou hotové a jsme připraveni parsovat soubory projektu InfColorPicker do počátečního souboru .h.h a projektu StructsAndEnums.cs InfColorPicker.

V aplikaci Terminal zadejte následující příkaz:

sharpie bind --output=InfColorPicker --namespace=InfColorPicker --sdk=[iphone-os] -scope [full-path-to-project]/InfColorPicker/InfColorPicker [full-path-to-project]/InfColorPicker/InfColorPicker/*.h

Kde je úplná cesta k adresáři, kde se na našem počítači nachází soubor projektu [full-path-to-project][full-path-to-project] Xcode, a [iphone-os] je sada SDK pro iOS, kterou jsme nainstalovali, jak je to z sharpie xcode -sdks příkazu . Všimněte si, že v tomto příkladu jsme předli *.h jako parametr, který zahrnuje všechny soubory hlaviček v tomto adresáři – normálně byste to NEMĚLI dělat, ale pečlivě si pročtěte soubory hlaviček, abyste našli soubor .h nejvyšší úrovně, který odkazuje na všechny ostatní relevantní soubory, a jednoduše ho předejte Objective Sharpiemu.

V terminálu se vygeneruje následující výstup:

Europa:Resources kmullins$ sharpie bind -output InfColorPicker -namespace InfColorPicker -sdk iphoneos8.1 /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h -unified
Compiler configuration:
    -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk -miphoneos-version-min=8.1 -resource-dir /Library/Frameworks/ObjectiveSharpie.framework/Versions/1.1.1/clang-resources -arch armv7 -ObjC

[  0%] parsing /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h
In file included from /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h:60:
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:28:1: warning: no 'assign',
      'retain', or 'copy' attribute is specified - 'assign' is assumed [-Wobjc-property-no-attribute]
@property (nonatomic) UIColor* sourceColor;
^
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:28:1: warning: default property
      attribute 'assign' not appropriate for non-GC object [-Wobjc-property-no-attribute]
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:29:1: warning: no 'assign',
      'retain', or 'copy' attribute is specified - 'assign' is assumed [-Wobjc-property-no-attribute]
@property (nonatomic) UIColor* resultColor;
^
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:29:1: warning: default property
      attribute 'assign' not appropriate for non-GC object [-Wobjc-property-no-attribute]
4 warnings generated.
[100%] parsing complete
[bind] InfColorPicker.cs
Europa:Resources kmullins$

V našem adresáři se vytvoří soubory InfColorPicker.enums.cs a InfColorPicker.cs:

Normalizace definic rozhraní API

Objective Sharpie má někdy problém s překladem , takže budeme muset upravit definici rozhraní a nahradit řádek DelegatesInfColorPickerControllerDelegate následujícím [Protocol, Model] kódem:

[BaseType(typeof(NSObject))]
[Model]

Aby definice vypadala jako:

V dalším kroku uděláme totéž s obsahem souboru a zkopírujeme je do souboru a ponecháme příkazy InfColorPicker.enums.csStructsAndEnums.csusing beze změny:

Můžete také zjistit, že Objective Sharpie anotoval vazbu [Verify] atributy. Tyto atributy indikují, že byste měli ověřit, že Objective Sharpie udělal správnou věc porovnáním vazby s původní deklarací jazyka C/ (která bude k dispozici v komentáři nad Objective-C vázanou deklarací). Po ověření vazeb byste měli odebrat atribut verify. Další informace najdete v průvodci ověřením.

Použití vazby

Postupujte podle těchto kroků a vytvořte ukázkovou aplikaci iPhone, která bude používat knihovnu vazeb pro iOS vytvořenou výše:

V dalším kroku se rychle podíváme na protokoly v souboru a na to, jak je zvládáme ve vazbě a kódu Objective-C jazyka C#.

Protokoly a Xamarin.iOS

V Objective-C systému protokol definuje metody (nebo zprávy), které lze za určitých okolností použít. Koncepčně jsou velmi podobné rozhraním v jazyce C#. Jedním z hlavních rozdílů mezi protokolem a rozhraním jazyka C# je to, že protokoly mohou mít volitelné metody – metody, které třída Objective-C nemusí implementovat. Objective-C používá klíčové @optional se používá k označení metod, které jsou volitelné. Další informace o protokolech najdete v tématu Události, protokoly a delegáti.

InfColorPickerController má jeden takový protokol, který je zobrazený v následujícím fragmentu kódu:

@protocol InfColorPickerControllerDelegate

@optional

- (void) colorPickerControllerDidFinish: (InfColorPickerController*) controller;
// This is only called when the color picker is presented modally.

- (void) colorPickerControllerDidChangeColor: (InfColorPickerController*) controller;

@end

Tento protokol používá InfColorPickerController k informování klientů, že uživatel vybral novou barvu a že je dokončený InfColorPickerController. Objective Sharpie namapoval tento protokol, jak je znázorněno v následujícím fragmentu kódu:

[BaseType(typeof(NSObject))]
[Model]
public partial interface InfColorPickerControllerDelegate {

    [Export ("colorPickerControllerDidFinish:")]
    void ColorPickerControllerDidFinish (InfColorPickerController controller);

    [Export ("colorPickerControllerDidChangeColor:")]
    void ColorPickerControllerDidChangeColor (InfColorPickerController controller);
}

Při kompilaci knihovny vazeb vytvoří Xamarin.iOS abstraktní základní třídu s názvem , která implementuje toto rozhraní s InfColorPickerControllerDelegate virtuálními metodami.

Toto rozhraní můžeme implementovat v aplikaci Xamarin.iOS dvěma způsoby:

• Silný delegát – Použití silného delegáta zahrnuje vytvoření třídy jazyka C#, která podtřídy a přepisuje příslušné metody. InfColorPickerController použije instanci této třídy ke komunikaci se svými klienty.
• Slabý delegát – Slabý delegát je mírně odlišná technika, která zahrnuje vytvoření veřejné metody v některé třídě (například ) a následné vystavení této metody protokolu prostřednictvím InfColorPickerDelegateExport atributu.

Silné delegáty poskytují IntelliSense, bezpečnost typů a lepší zapouzdření. Z těchto důvodů byste měli používat silné delegáty tam, kde můžete místo slabého delegáta.

V tomto návodu budeme pojednávat o obou postupech: první implementace silného delegáta a vysvětluje, jak implementovat slabý delegát.

Implementace silného delegáta

Dokončete aplikaci Xamarin. iOS pomocí silného delegáta, který odpoví na colorPickerControllerDidFinish: zprávu:

InfColorPickerControllerDelegate podtříd – přidejte novou třídu do projektu s názvem . Upravte třídu tak, aby měla následující kód:

using InfColorPickerBinding;
using UIKit;

namespace InfColorPickerSample
{
  public class ColorSelectedDelegate:InfColorPickerControllerDelegate
  {
    readonly UIViewController parent;

    public ColorSelectedDelegate (UIViewController parent)
    {
      this.parent = parent;
    }

    public override void ColorPickerControllerDidFinish (InfColorPickerController controller)
    {
      parent.View.BackgroundColor = controller.ResultColor;
      parent.DismissViewController (false, null);
    }
  }
}

Xamarin. iOS vytvoří vazby Objective-C delegáta vytvořením abstraktní základní třídy s názvem InfColorPickerControllerDelegate . Podtřída tohoto typu a přepíše ColorPickerControllerDidFinish metodu pro přístup k hodnotě ResultColor vlastnosti InfColorPickerController .

Vytvoření instance ColorSelectedDelegate – naše obslužná rutina události bude potřebovat instanci typu, kterou jsme vytvořili v předchozím kroku. Upravte třídu InfColorPickerSampleViewController a přidejte do třídy následující proměnnou instance:

ColorSelectedDelegate selector;

Inicializujte proměnnou ColorSelectedDelegate – Chcete-li zajistit, že je platná instance, aktualizujte metodu ViewDidLoad in ViewController tak, aby odpovídala následujícímu fragmentu kódu:

public override void ViewDidLoad ()
{
  base.ViewDidLoad ();
  ChangeColorButton.TouchUpInside += HandleTouchUpInsideWithStrongDelegate;
  selector = new ColorSelectedDelegate (this);
}

Implementujte metodu HandleTouchUpInsideWithStrongDelegate -Next Implementujte obslužnou rutinu události, aby se uživatel dotkl ColorChangeButton. Upravte ViewController a přidejte následující metodu:

using InfColorPicker;
...

private void HandleTouchUpInsideWithStrongDelegate (object sender, EventArgs e)
{
    InfColorPickerController picker = InfColorPickerController.ColorPickerViewController();
    picker.Delegate = selector;
    picker.PresentModallyOverViewController (this);
}

Nejprve získáme instanci InfColorPickerController prostřednictvím statické metody a tuto instanci si poznáte u našeho silného delegáta prostřednictvím vlastnosti InfColorPickerController.Delegate . Tato vlastnost se pro nás vygenerovala automaticky pro účelově ostře. Nakonec voláme, PresentModallyOverViewController aby se zobrazení zobrazilo InfColorPickerSampleViewController.xib , aby uživatel mohl vybrat barvu.

Spustit aplikaci – v tomto okamžiku jsme hotovi s celým kódem. Při spuštění aplikace byste měli být schopni změnit barvu pozadí, InfColorColorPickerSampleView jak je znázorněno na následujících snímcích obrazovky:

Gratulujeme! V tuto chvíli jste úspěšně vytvořili a nastavili vazbu Objective-C knihovny pro použití v aplikaci Xamarin. iOS. Pojďme se seznámit s používáním slabých delegátů.

Implementace slabého delegáta

Namísto roztřídění třídy vázané na Objective-C protokol pro konkrétního delegáta umožňuje Xamarin. iOS také implementovat metody protokolu v jakékoli třídě, která je odvozena z NSObject , upravení své metody s ExportAttribute a pak poskytují příslušné selektory. Při uplatnění tohoto přístupu přiřadíte instanci třídy k WeakDelegate vlastnosti namísto Delegate Vlastnosti. Slabý delegát nabízí flexibilitu pro převzetí třídy delegáta mimo jinou hierarchii dědičnosti. Pojďme se podívat, jak implementovat a používat slabý delegáta v naší aplikaci Xamarin. iOS.

Vytvořit obslužnou rutinu události pro TouchUpInside – umožňuje vytvořit novou obslužnou rutinu události pro Událost tlačítka změnit barvu pozadí. Tato obslužná rutina vyplní stejnou roli jako HandleTouchUpInsideWithStrongDelegate obslužná rutina, kterou jsme vytvořili v předchozí části, ale bude používat slabý delegát místo silného delegáta. Upravte třídu ViewController a přidejte následující metodu:

private void HandleTouchUpInsideWithWeakDelegate (object sender, EventArgs e)
{
    InfColorPickerController picker = InfColorPickerController.ColorPickerViewController();
    picker.WeakDelegate = this;
    picker.SourceColor = this.View.BackgroundColor;
    picker.PresentModallyOverViewController (this);
}

Aktualizace ViewDidLoad – musíme změnit tak, aby používala obslužnou rutinu události, kterou jsme právě vytvořili. Upravit ViewController a změnit ViewDidLoad tak, aby vypadaly jako následující fragment kódu:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();
    ChangeColorButton.TouchUpInside += HandleTouchUpInsideWithWeakDelegate;
}

Zpracování colorPickerControllerDidFinish: zpráva – po dokončení bude iOS odesílat zprávy colorPickerControllerDidFinish: do WeakDelegate . Musíme vytvořit metodu jazyka C#, která může tuto zprávu zpracovat. K tomuto účelu vytvoříme metodu jazyka C# a pak ji můžete přizpůsobovat s ExportAttribute . Upravte ViewController a do třídy přidejte následující metodu:

[Export("colorPickerControllerDidFinish:")]
public void ColorPickerControllerDidFinish (InfColorPickerController controller)
{
    View.BackgroundColor = controller.ResultColor;
    DismissViewController (false, null);
}

Spusťte aplikaci. Měl by se teď chovat přesně stejně jako předtím, ale používá slabý delegát místo silného delegáta. V tuto chvíli jste úspěšně dokončili tento návod. Nyní byste měli mít přehled o tom, jak vytvořit a využívat projekt vazby Xamarin. iOS.

Souhrn

Tento článek vás provedl procesem vytváření a používání projektu vazby Xamarin. iOS. Nejprve jsme probrali, jak zkompilovat existující Objective-C knihovnu do statické knihovny. Pak jsme pokryli, jak vytvořit projekt vazby Xamarin. iOS a jak používat objektivní ostrost pro generování definic rozhraní API pro Objective-C knihovnu. Provedli jsme postup aktualizace a vylepšení vygenerovaných definic rozhraní API, aby byly vhodné pro zajištění veřejné spotřeby. Po dokončení projektu vazby Xamarin. iOS jsme přešli na používání této vazby v aplikaci Xamarin. iOS s fokusem na používání silných delegátů a slabých delegátů.

Související odkazy

• Binding Objective-C Libraries
• Podrobnosti vazby
• Referenční příručka typů vazeb
• Xamarin for Objective-C Developers
• Pokyny k návrhu architektury