Procedura dettagliata: Associazione di una libreria iOS Objective-C

Importante

Attualmente si sta esaminando l'utilizzo di binding personalizzato nella piattaforma Xamarin. Per informare i futuri sforzi di sviluppo, si prega di prendere questa indagine .

Questo articolo fornisce una procedura dettagliata per la creazione di un binding Xamarin.iOS per una libreria esistente Objective-C , InfColorPicker. Vengono illustrati argomenti come la compilazione di una libreria statica Objective-C , l'associazione e l'uso dell'associazione in un'applicazione Xamarin.iOS.

Quando si lavora su iOS, è possibile che si verifichino casi in cui si vuole usare una libreria di terze parti Objective-C . In queste situazioni, è possibile usare un'Project di associazione Xamarin.iOS per creare un'associazione C# che consente di usare la libreria nelle applicazioni Xamarin.iOS.

In genere nell'ecosistema iOS è possibile trovare librerie in 3 sapori:

• Come file di libreria statica precompilato con .a estensione insieme alle relative intestazioni (file.h). Ad esempio, la libreria di Analisi di Google
• Come framework precompilato. Questa è solo una cartella contenente la libreria statica, le intestazioni e talvolta risorse aggiuntive con .framework estensione. Ad esempio, La libreria AdMob di Google.
• Come solo file di codice sorgente. Ad esempio, una libreria contenente file just .m e .h Objective C.

Nel primo e secondo scenario sarà già presente una libreria statica CocoaTouch precompilata, quindi in questo articolo ci si concentrerà sul terzo scenario. Ricordatevi, prima di iniziare a creare un'associazione, controllare sempre la licenza fornita con la libreria per assicurarsi che sia libero di associarlo.

Questo articolo fornisce una procedura dettagliata per la creazione di un progetto di associazione usando il progetto open source InfColorPickerObjective-C come esempio, tuttavia tutte le informazioni contenute in questa guida possono essere adattate per l'uso con qualsiasi libreria di terze partiObjective-C. La libreria InfColorPicker fornisce un controller di visualizzazione riutilizzabile che consente all'utente di selezionare un colore in base alla relativa rappresentazione HSB, rendendo la selezione dei colori più descrittiva.

Verranno illustrati tutti i passaggi necessari per usare questa particolare Objective-C API in Xamarin.iOS:

• In primo luogo, verrà creata una Objective-C libreria statica usando Xcode.
• Verrà quindi associata questa libreria statica con Xamarin.iOS.
• Mostra quindi come Objective Sharpie può ridurre il carico di lavoro generando automaticamente alcuni (ma non tutti) delle definizioni API necessarie richieste dall'associazione Xamarin.iOS.
• Infine, creeremo un'applicazione Xamarin.iOS che usa l'associazione.

L'applicazione di esempio illustra come usare un delegato sicuro per la comunicazione tra l'API InfColorPicker e il codice C#. Dopo aver visto come usare un delegato sicuro, verrà illustrato come usare delegati deboli per eseguire le stesse attività.

Requisiti

Questo articolo presuppone che si abbia familiarità con Xcode e il linguaggio e si ha letto la documentazione sull'associazione Objective-CObjective-C. È inoltre necessario completare i passaggi presentati:

• Xcode e iOS SDK: Xcode di Apple e l'API iOS più recente devono essere installate e configurate nel computer dello sviluppatore.
• Strumenti da riga di comando Xcode: gli strumenti della riga di comando Xcode devono essere installati per la versione attualmente installata di Xcode (vedere di seguito per i dettagli sull'installazione).
• Visual Studio per Mac o Visual Studio: la versione più recente di Visual Studio per Mac o Visual Studio deve essere installata e configurata nel computer di sviluppo. Per lo sviluppo di un'applicazione Xamarin.iOS è necessario un Mac Apple e quando si usa Visual Studio è necessario essere connessi a un host di compilazione Xamarin.iOS
• La versione più recente di Objective Sharpie - Copia corrente dello strumento Objective Sharpie scaricata da qui. Se è già installato Objective Sharpie, è possibile aggiornarlo alla versione più recente usando sharpie update

Installazione degli strumenti della riga di comando Xcode

Visual Studio per Mac

Come indicato in precedenza, si useranno strumenti da riga di comando Xcode (in particolare make e lipo) in questa procedura dettagliata. Il make comando è un'utilità Unix molto comune che automatizza la compilazione di programmi eseguibili e librerie usando un makefile che specifica la modalità di compilazione del programma. Il lipo comando è un'utilità della riga di comando os X per la creazione di file a più architetture. Combina più .a file in un file che può essere usato da tutte le architetture hardware.

Visual Studio

Come indicato in precedenza, si useranno gli strumenti della riga di comando Xcode nell'host di compilazione Mac (in particolare make e lipo) in questa procedura dettagliata. Il make comando è un'utilità Unix molto comune che automatizza la compilazione di programmi eseguibili e librerie usando un makefile per specificare come compilare il programma. Il lipo comando è un'utilità della riga di comando os X per la creazione di file a più architetture. Combina più .a file in un file che può essere usato da tutte le architetture hardware.

In base alla compilazione di Apple dalla riga di comando con la documentazione delle domande frequenti su Xcode , in OS X 10.9 e versioni successive, il riquadro Download della finestra di dialogo Preferenze Xcode non supporta più il download degli strumenti da riga di comando.

È necessario usare uno dei metodi seguenti per installare gli strumenti:

• Installare Xcode : quando si installa Xcode, viene fornito in bundle con tutti gli strumenti della riga di comando. In OS X 10.9 shim (installato in /usr/bin), può eseguire il mapping di qualsiasi strumento incluso nello strumento corrispondente all'interno /usr/bin di Xcode. Ad esempio, il xcrun comando, che consente di trovare o eseguire qualsiasi strumento all'interno di Xcode dalla riga di comando.

• Applicazione terminale - Dall'applicazione Terminale è possibile installare gli strumenti della riga di comando eseguendo il xcode-select --install comando:

  • Avviare l'applicazione terminale.
  • Digitare xcode-select --install e premere INVIO, ad esempio:

  Europa:~ kmullins$ xcode-select --install
  

  • Verrà chiesto di installare gli strumenti della riga di comando, fare clic sul pulsante Installa :

  • Gli strumenti verranno scaricati e installati dai server apple:

• Download per gli sviluppatori Apple : il pacchetto Degli strumenti della riga di comando è disponibile la pagina Web Download per gli sviluppatori Apple . Accedere con l'ID Apple, quindi cercare e scaricare gli strumenti della riga di comando:

Con gli strumenti della riga di comando installati, è possibile continuare con la procedura dettagliata.

Procedura dettagliata

In questa procedura dettagliata verranno illustrati i passaggi seguenti:

• Creare una libreria statica : questo passaggio implica la creazione di una libreria statica del codice InfColorPickerObjective-C . La libreria statica avrà l'estensione .a del file e verrà incorporata nell'assembly .NET del progetto di libreria.
• Creare una Project di associazione Xamarin.iOS: dopo aver creato una libreria statica, verrà usata per creare un progetto di associazione Xamarin.iOS. Il progetto di associazione è costituito dalla libreria statica appena creata e dai metadati sotto forma di codice C# che spiega come è possibile usare l'API Objective-C . Questi metadati vengono comunemente definiti definizioni API. Useremo Objective Sharpie per aiutarci a creare le definizioni dell'API.
• Normalizzare le definizioni dell'API : Objective Sharpie fa un ottimo lavoro per aiutarci, ma non può fare tutto. Verranno illustrate alcune modifiche che è necessario apportare alle definizioni dell'API prima che possano essere usate.
• Usare la libreria di binding: infine, verrà creata un'applicazione Xamarin.iOS per illustrare come usare il progetto di associazione appena creato.

Dopo aver compreso quali passaggi sono coinvolti, passare al resto della procedura dettagliata.

Creazione di una libreria statica

Se si esamina il codice per InfColorPicker in Github:

Nel progetto sono disponibili tre directory seguenti:

• InfColorPicker : questa directory contiene il Objective-C codice per il progetto.
• PickerSamplePad: questa directory contiene un progetto di esempio iPad.
• PickerSamplePhone: questa directory contiene un progetto di esempio iPhone.

Scaricare il progetto InfColorPicker da GitHub e decomprimerlo nella directory della scelta. Apertura della destinazione Xcode per PickerSamplePhone il progetto, viene visualizzata la struttura di progetto seguente in Xcode Navigator:

Questo progetto ottiene il riutilizzo del codice aggiungendo direttamente il codice sorgente InfColorPicker (nella casella rossa) in ogni progetto di esempio. Il codice per il progetto di esempio si trova all'interno della casella blu. Poiché questo particolare progetto non fornisce una libreria statica, è necessario creare un progetto Xcode per compilare la libreria statica.

Il primo passaggio consiste nell'aggiungere il codice sorgente InfoColorPicker alla libreria statica. Per ottenere questo risultato, eseguire le operazioni seguenti:

1. Avviare Xcode.

2. Dal menu File selezionare Nuovo>Project...:

   

3. Selezionare Libreria framework&, il modello Di libreria statica Cocoa Touch e fare clic sul pulsante Avanti:

   

4. Immettere InfColorPicker per il nome Project e fare clic sul pulsante Avanti:

   

5. Selezionare un percorso per salvare il progetto e fare clic sul pulsante OK .

6. È ora necessario aggiungere l'origine dal progetto InfColorPicker al progetto di libreria statica. Poiché il file InfColorPicker.h esiste già nella libreria statica (per impostazione predefinita), Xcode non consente di sovrascriverlo. Dal Finder passare al codice sorgente InfColorPicker nel progetto originale non compresso da GitHub, copiare tutti i file InfColorPicker e incollarli nel nuovo progetto di libreria statica:

   

7. Tornare a Xcode, fare clic con il pulsante destro del mouse sulla cartella InfColorPicker e selezionare Aggiungi file a "InfColorPicker...":

   

8. Nella finestra di dialogo Aggiungi file passare ai file di codice sorgente InfColorPicker appena copiati, selezionarli tutti e fare clic sul pulsante Aggiungi :

   

9. Il codice sorgente verrà copiato nel progetto:

   

10. Dal Project Navigatore di Xcode selezionare il file InfColorPicker.m e commentare le ultime due righe (a causa del modo in cui questa libreria è stata scritta, questo file non viene usato):

    

11. È ora necessario verificare se sono presenti framework richiesti dalla libreria. È possibile trovare queste informazioni in README o aprendo uno dei progetti di esempio forniti. In questo esempio viene usato Foundation.framework, UIKit.frameworke CoreGraphics.framework quindi verranno aggiunti.

12. Selezionare le fasi di compilazione di > destinazione InfColorPicker e espandere la sezione Link Binary With Libraries :

    

13. Usare il pulsante per aprire la + finestra di dialogo che consente di aggiungere i framework fotogrammi necessari elencati in precedenza:

    

14. La sezione Link Binary With Libraries dovrebbe ora essere simile all'immagine seguente:

    

A questo punto siamo vicini, ma non siamo abbastanza fatti. La libreria statica è stata creata, ma è necessario crearla per creare un file binario Fat che include tutte le architetture necessarie per il dispositivo iOS e il simulatore iOS.

Creazione di un file binario grasso

Tutti i dispositivi iOS hanno processori basati sull'architettura arm sviluppata nel corso del tempo. Ogni nuova architettura ha aggiunto nuove istruzioni e altri miglioramenti mantenendo comunque la compatibilità con le versioni precedenti. I dispositivi iOS hanno armv6, armv7, armv7s, set di istruzioni arm64, anche se armv6 non è più usato. Il simulatore iOS non è basato su ARM ed è invece un simulatore x86 e x86_64 simulatore alimentato. Ciò significa che le librerie devono essere fornite per ogni set di istruzioni.

Una libreria Fat è .a un file contenente tutte le architetture supportate.

La creazione di un binario grasso è un processo in tre passaggi:

• Compilare una versione arm 7 & ARM64 della libreria statica.
• Compilare una versione x86 e x84_64 della libreria statica.
• Usare lo strumento della lipo riga di comando per combinare le due librerie statiche in una.

Anche se questi tre passaggi sono piuttosto semplici, potrebbe essere necessario ripeterli in futuro quando la Objective-C libreria riceve gli aggiornamenti o se è necessaria la correzione di bug. Se si decide di automatizzare questi passaggi, semplifica la manutenzione futura e il supporto del progetto di associazione iOS.

Sono disponibili molti strumenti per automatizzare tali attività: uno script shell, rake, xbuild e make. Quando vengono installati gli strumenti della riga di comando Xcode, make viene installato anche il sistema di compilazione che verrà usato per questa procedura dettagliata. Ecco un Makefile che è possibile usare per creare una libreria condivisa multi-architettura che funzionerà su un dispositivo iOS e il simulatore per qualsiasi libreria:

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

Immettere i comandi Makefile nell'editor di testo normale della scelta e aggiornare le sezioni con YOUR-PROJECT-NAME con il nome del progetto. È anche importante assicurarsi di incollare le istruzioni sopra esattamente, con le schede all'interno delle istruzioni mantenute.

Salvare il file con il nome Makefile nella stessa posizione della libreria statica InfColorPicker creata in precedenza:

Aprire l'applicazione terminale sul Mac e passare alla posizione del makefile. Digitare make nel terminale, premere INVIO e verrà eseguito Il file Makefile :

Quando si esegue, verrà visualizzato un sacco di testo scorrevole in base. Se tutto ha funzionato correttamente, verranno visualizzate le parole BUILD SUCCESSED e i libInfColorPicker-armv7.alibInfColorPicker-i386.a file e libInfColorPickerSDK.a verranno copiati nello stesso percorso del Makefile:

È possibile confermare le architetture all'interno del file binario Fat usando il comando seguente:

xcrun -sdk iphoneos lipo -info libInfColorPicker.a

Verrà visualizzato quanto segue:

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

A questo punto, è stato completato il primo passaggio dell'associazione iOS creando una libreria statica usando Xcode e gli strumenti make della riga di comando Xcode e lipo. Passare al passaggio successivo e usare Objective-Sharpie per automatizzare la creazione delle associazioni API per l'utente.

Creare un'associazione Xamarin.iOS Project

Prima di poter usare Objective-Sharpie per automatizzare il processo di associazione, è necessario creare un binding Xamarin.iOS Project per ospitare le definizioni api (che useremo Objective-Sharpie per aiutarci a compilare) e creare l'associazione C# per noi.

Eseguire le operazioni seguenti:

Visual Studio per Mac

1. Avviare Visual Studio per Mac.

2. Dal menu File selezionare NewSolution>...:

   

3. Nella finestra di dialogo Nuova soluzione selezionare BindingLibraryiOS> Project:

   

4. Fare clic sul pulsante Next (Avanti).

5. Immettere "InfColorPickerBinding" come nome Project e fare clic sul pulsante Crea per creare la soluzione:

   

La soluzione verrà creata e verranno inclusi due file predefiniti:

Visual Studio

1. Avviare Visual Studio.

2. Dal menu File selezionare Nuovo>Project...:

   

3. Nella finestra di dialogo Nuovo Project selezionare Visual C# > iPhone iPad &> libreria di associazioni iOS (Xamarin):

   

4. Immettere "InfColorPickerBinding" come nome e fare clic sul pulsante OK per creare la soluzione.

La soluzione verrà creata e verranno inclusi due file predefiniti:

• ApiDefinition.cs : questo file conterrà i contratti che definiscono la modalità Objective-C di wrapping dell'API in C#.
• Structs.cs : questo file contiene eventuali strutture o valori di enumerazione richiesti dalle interfacce e dai delegati.

Questi due file verranno usati più avanti nella procedura dettagliata. Prima di tutto, è necessario aggiungere la libreria InfColorPicker al progetto di associazione.

Inclusione della libreria statica nell'Project di associazione

Ora è disponibile l'associazione di base Project pronta, è necessario aggiungere la libreria Binaria Fat creata in precedenza per la libreria InfColorPicker.

Seguire questa procedura per aggiungere la libreria:

Visual Studio per Mac

1. Fare clic con il pulsante destro del mouse sulla cartella Riferimenti nativi nel riquadro della soluzione e scegliere Aggiungi riferimenti nativi:

   

2. Passare al file Binario grasso eseguito in precedenza (libInfColorPickerSDK.a) e premere il pulsante Apri :

   

3. Il file verrà incluso nel progetto:

   

Visual Studio

1. Copiare l'oggetto dall'host libInfColorPickerSDK.a di compilazione Mac e incollarlo nel progetto di associazione.

2. Fare clic con il pulsante destro del mouse sul progetto e scegliere Aggiungi > elemento esistente...:

   

3. Passare all'oggetto libInfColorPickerSDK.a e premere il pulsante Aggiungi :

   

4. Il file verrà incluso nel progetto.

Quando il file viene aggiunto al progetto, Xamarin.iOS imposta automaticamente l'azione di compilazione del file su ObjcBindingNativeLibrary e crea un file speciale denominato libInfColorPickerSDK.linkwith.cs.

Questo file contiene l'attributo LinkWith che indica a Xamarin.iOS come gestire la libreria statica appena aggiunta. Il contenuto di questo file è illustrato nel frammento di codice seguente:

using ObjCRuntime;

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

L'attributo LinkWith identifica la libreria statica per il progetto e alcuni flag di linker importanti.

La prossima operazione da eseguire consiste nel creare le definizioni API per il progetto InfColorPicker. Ai fini di questa procedura dettagliata, verrà usato Objective Sharpie per generare il file ApiDefinition.cs.

Uso di Objective Sharpie

Visual Studio per Mac

Objective Sharpie è uno strumento della riga di comando (fornito da Xamarin) che consente di creare le definizioni necessarie per associare una libreria di terze parti Objective-C a C#. In questa sezione verrà usato Objective Sharpie per creare l'apiDefinition.cs iniziale per il progetto InfColorPicker.

Visual Studio

Objective Sharpie è uno strumento della riga di comando (fornito da Xamarin) che consente di creare le definizioni necessarie per associare una libreria di terze parti Objective-C a C#. In questa sezione verrà usato Objective Sharpie nell'host di compilazione Mac per creare l'apiDefinition.cs iniziale per il progetto InfColorPicker.

Per iniziare, scaricare il file di installazione di Objective Sharpie come descritto in questa guida. Eseguire il programma di installazione e seguire tutte le richieste sullo schermo dalla procedura guidata di installazione per installare Objective Sharpie nel computer di sviluppo.

Dopo l'installazione di Objective Sharpie, è possibile avviare l'app Terminale e immettere il comando seguente per ottenere assistenza su tutti gli strumenti forniti per facilitare l'associazione:

sharpie -help

Se si esegue il comando precedente, verrà generato l'output seguente:

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

A scopo di questa procedura dettagliata, verranno usati gli strumenti Objective Sharpie seguenti:

• xcode : questo strumento fornisce informazioni sull'installazione corrente di Xcode e sulle versioni delle API iOS e Mac installate. Questa informazione verrà usata in un secondo momento quando vengono generate le associazioni.
• bind: questo strumento verrà usato per analizzare i file con estensione h nel progetto InfColorPicker nell'apiDefinition.cs iniziale e nei file StructsAndEnums.cs.

Per ottenere assistenza su uno strumento Objective Sharpie specifico, immettere il nome dello strumento e l'opzione -help . Ad esempio, sharpie xcode -help restituisce l'output seguente:

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.

Prima di avviare il processo di associazione, è necessario ottenere informazioni sugli SDK installati corrente immettendo il comando seguente nel terminale 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

Dall'articolo precedente è possibile notare che l'SDK iphoneos9.3 è installato nel computer. Con queste informazioni, è possibile analizzare i file di progetto .h InfColorPicker nell'apiDefinition.cs iniziale e StructsAndEnums.cs per il progetto InfColorPicker.

Immettere il comando seguente nell'app Terminale:

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

Dove [full-path-to-project] è il percorso completo della directory in cui si trova il file di progetto InfColorPicker Xcode nel computer e [iphone-os] è l'SDK iOS installato, come indicato dal sharpie xcode -sdks comando. Si noti che in questo esempio è stato passato *.h come parametro, che include tutti i file di intestazione in questa directory, in genere non è consigliabile eseguire questa operazione, ma leggere attentamente i file di intestazione per trovare il file con estensione h di primo livello che fa riferimento a tutti gli altri file pertinenti e passarlo solo a Objective Sharpie.

Suggerimento

Per l'argomento -scope passare la cartella con le intestazioni che si desidera associare. Senza l'argomento -scope , Objective Sharpie tenterà di generare associazioni per le intestazioni di iOS SDK importate, ad esempio #import <UIKit.h>, causando un file di definizioni enorme che genererà probabilmente errori durante la compilazione del progetto di associazione. Con il -scope set di argomenti, Objective Sharpie non genererà associazioni per le intestazioni esterne alla cartella con ambito.

L'output seguente verrà generato nel terminale:

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$

E i file InfColorPicker.enums.cs e InfColorPicker.cs verranno creati nella directory:

Visual Studio per Mac

Aprire entrambi questi file nel progetto binding creato in precedenza. Copiare il contenuto del file InfColorPicker.cs e incollarlo nel file ApiDefinition.cs , sostituendo il blocco di codice esistente namespace ... con il contenuto del file InfColorPicker.cs (lasciando invariate le using istruzioni):

Visual Studio

Aprire entrambi questi file nel progetto binding creato in precedenza. Copiare il contenuto del file InfColorPicker.cs ( dall'host di compilazione Mac) e incollarlo nel file ApiDefinition.cs , sostituendo il blocco di codice esistente namespace ... con il contenuto del file InfColorPicker.cs (lasciando invariate le using istruzioni).

Normalizzare le definizioni api

Objective Sharpie talvolta presenta un problema durante la conversione Delegatesdi , quindi sarà necessario modificare la definizione dell'interfaccia InfColorPickerControllerDelegate e sostituire la [Protocol, Model] riga con quanto segue:

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

In modo che la definizione sia simile alla seguente:

Successivamente, si esegue la stessa operazione con il contenuto del InfColorPicker.enums.cs file, copiandoli e incollandoli nel StructsAndEnums.cs file lasciando intatte le using istruzioni:

È anche possibile notare che Objective Sharpie ha annotato l'associazione con [Verify] gli attributi. Questi attributi indicano che è necessario verificare che Objective Sharpie abbia eseguito l'operazione corretta confrontando l'associazione con la dichiarazione C/Objective-C originale (che verrà fornita in un commento sopra la dichiarazione associata). Dopo aver verificato le associazioni, è necessario rimuovere l'attributo verify. Per altre informazioni, vedere la guida Verifica .

Visual Studio per Mac

A questo punto, il progetto di associazione deve essere completo e pronto per la compilazione. Compilare il progetto di associazione e assicurarsi che non siano stati generati errori:

Compilare il progetto di associazione e assicurarsi che non siano presenti errori

Visual Studio

A questo punto, il progetto di associazione deve essere completo e pronto per la compilazione. Compilare il progetto di associazione e assicurarsi che non siano stati generati errori.

Uso dell'associazione

Seguire questa procedura per creare un'applicazione di esempio iPhone per usare la libreria di binding iOS creata in precedenza:

Visual Studio per Mac

1. Creare il Project Xamarin.iOS: aggiungere un nuovo progetto Xamarin.iOS denominato InfColorPickerSample alla soluzione, come illustrato negli screenshot seguenti:

   

   

2. Aggiungi riferimento al binding Project : aggiornare il progetto InfColorPickerSample in modo che abbia un riferimento al progetto InfColorPickerBinding:

   

3. Creare l'interfaccia utente di iPhone: fare doppio clic sul file MainStoryboard.storyboard nel progetto InfColorPickerSample per modificarlo in iOS Designer. Aggiungere un pulsante alla visualizzazione e chiamarlo ChangeColorButton, come illustrato di seguito:

   

4. Aggiungere InfColorPickerView.xib : la libreria InfColorPicker Objective-C include un file con estensione xib . Xamarin.iOS non includerà questo file con estensione xib nel progetto di associazione, causando errori di runtime nell'applicazione di esempio. La soluzione alternativa consiste nell'aggiungere il file xib al progetto Xamarin.iOS. Selezionare il progetto Xamarin.iOS, fare clic con il pulsante destro del mouse e scegliere Aggiungi > file e aggiungere il file xib , come illustrato nello screenshot seguente:

   

5. Quando richiesto, copiare il file con estensione xib nel progetto.

Visual Studio

1. Creare Project Xamarin.iOS: aggiungere un nuovo progetto Xamarin.iOS denominato InfColorPickerSample usando il modello App a visualizzazione singola:

   

   

2. Aggiungi riferimento al binding Project : aggiornare il progetto InfColorPickerSample in modo che abbia un riferimento al progetto InfColorPickerBinding:

   

3. Creare l'interfaccia utente di iPhone: fare doppio clic sul file MainStoryboard.storyboard nel progetto InfColorPickerSample per modificarlo in iOS Designer. Aggiungere un pulsante alla visualizzazione e chiamarlo ChangeColorButton, come illustrato di seguito:

   

4. Aggiungere InfColorPickerView.xib : la libreria InfColorPicker Objective-C include un file con estensione xib . Xamarin.iOS non includerà questo file con estensione xib nel progetto di associazione, causando errori di runtime nell'applicazione di esempio. La soluzione alternativa consiste nell'aggiungere il file xib al progetto Xamarin.iOS dall'host di compilazione Mac. Selezionare il progetto Xamarin.iOS, fare clic con il pulsante destro del mouse e scegliere AggiungiElemento> esistente e aggiungere il file con estensione xib.

Verranno ora esaminati rapidamente i protocolli in Objective-C e il modo in cui vengono gestiti nel codice C# e nell'associazione.

Protocolli e Xamarin.iOS

In Objective-Cun protocollo definisce metodi (o messaggi) che possono essere usati in determinate circostanze. Concettualmente, sono molto simili alle interfacce in C#. Una differenza principale tra un Objective-C protocollo e un'interfaccia C# è che i protocolli possono avere metodi facoltativi, ovvero metodi che una classe non deve implementare. Objective-C usa la @optional parola chiave per indicare quali metodi sono facoltativi. Per altre informazioni sui protocolli, vedere Eventi, protocolli e delegati.

InfColorPickerController ha un protocollo di questo tipo, illustrato nel frammento di codice seguente:

@protocol InfColorPickerControllerDelegate

@optional

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

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

@end

Questo protocollo viene usato da InfColorPickerController per informare i client che l'utente ha scelto un nuovo colore e che InfColorPickerController è terminato. Objective Sharpie ha eseguito il mapping di questo protocollo come illustrato nel frammento di codice seguente:

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

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

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

Quando la libreria di binding viene compilata, Xamarin.iOS creerà una classe base astratta denominata InfColorPickerControllerDelegate, che implementa questa interfaccia con i metodi virtuali.

Esistono due modi per implementare questa interfaccia in un'applicazione Xamarin.iOS:

• Delegato sicuro: l'uso di un delegato sicuro comporta la creazione di una classe C# che sottoclassa ed esegue l'override InfColorPickerControllerDelegate dei metodi appropriati. InfColorPickerController userà un'istanza di questa classe per comunicare con i client.
• Delegato debole: un delegato debole è una tecnica leggermente diversa che implica la creazione di un metodo pubblico in una classe (ad esempio InfColorPickerSampleViewController) e quindi l'esposizione di tale metodo al InfColorPickerDelegate protocollo tramite un Export attributo .

I delegati sicuri forniscono IntelliSense, sicurezza dei tipi e incapsulamento migliore. Per questi motivi, è consigliabile usare delegati sicuri in cui è possibile, anziché un delegato debole.

In questa procedura dettagliata verranno illustrate entrambe le tecniche: implementare prima un delegato sicuro e quindi spiegare come implementare un delegato debole.

Implementazione di un delegato sicuro

Completare l'applicazione Xamarin.iOS usando un delegato sicuro per rispondere al colorPickerControllerDidFinish: messaggio:

Sottoclasse InfColorPickerControllerDelegate : aggiungere una nuova classe al progetto denominato ColorSelectedDelegate. Modificare la classe in modo che abbia il codice seguente:

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 associa il Objective-C delegato creando una classe base astratta denominata InfColorPickerControllerDelegate. Sottoclasse questo tipo ed eseguire l'override del ColorPickerControllerDidFinish metodo per accedere al valore della ResultColor proprietà di InfColorPickerController.

Creare un'istanza di ColorSelectedDelegate : il gestore eventi richiederà un'istanza del ColorSelectedDelegate tipo creato nel passaggio precedente. Modificare la classe InfColorPickerSampleViewController e aggiungere la variabile di istanza seguente alla classe :

ColorSelectedDelegate selector;

Inizializzare la variabile ColorSelectedDelegate : per assicurarsi che selector sia un'istanza valida, aggiornare il metodo ViewDidLoad in ViewController in modo che corrisponda al frammento di codice seguente:

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

Implementare il metodo HandleTouchUpInsideWithStrongDelegate - Next implementa il gestore eventi per quando l'utente tocca ColorChangeButton. Modificare ViewControllere aggiungere il metodo seguente:

using InfColorPicker;
...

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

Per prima cosa si ottiene un'istanza di InfColorPickerController tramite un metodo statico e si rende tale istanza consapevole del delegato sicuro tramite la proprietà InfColorPickerController.Delegate. Questa proprietà è stata generata automaticamente da Objective Sharpie. Infine viene chiamato PresentModallyOverViewController per visualizzare la visualizzazione InfColorPickerSampleViewController.xib in modo che l'utente possa selezionare un colore.

Eseguire l'applicazione : a questo punto il codice è stato completato. Se si esegue l'applicazione, dovrebbe essere possibile modificare il colore di sfondo di InfColorColorPickerSampleView come illustrato negli screenshot seguenti:

Congratulazioni! A questo punto è stata creata e associata correttamente una Objective-C libreria da usare in un'applicazione Xamarin.iOS. Verranno ora fornite informazioni sull'uso di delegati deboli.

Implementazione di un delegato debole

Anziché sottoclassare una classe associata al Objective-C protocollo per un delegato specifico, Xamarin.iOS consente anche di implementare i metodi di protocollo in qualsiasi classe che deriva da NSObject, decorare i metodi con ExportAttributee quindi fornire i selettori appropriati. Quando si accetta questo approccio, si assegna un'istanza della classe alla WeakDelegate proprietà anziché alla Delegate proprietà . Un delegato debole offre la flessibilità necessaria per ridurre la classe del delegato in una gerarchia di ereditarietà diversa. Di seguito viene illustrato come implementare e usare un delegato debole nell'applicazione Xamarin.iOS.

Crea gestore eventi per TouchUpInside : creiamo un nuovo gestore eventi per l'evento TouchUpInside del pulsante Cambia colore di sfondo. Questo gestore riempirà lo stesso ruolo del HandleTouchUpInsideWithStrongDelegate gestore creato nella sezione precedente, ma userà un delegato debole anziché un delegato sicuro. Modificare la classe ViewControllere aggiungere il metodo seguente:

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

Update ViewDidLoad : è necessario modificare ViewDidLoad in modo che usi il gestore eventi appena creato. Modificare ViewController e modificare ViewDidLoad in modo che sia simile al frammento di codice seguente:

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

Gestire colorPickerControllerDidFinish: Message - Al ViewController termine, iOS invierà il messaggio colorPickerControllerDidFinish: a WeakDelegate. È necessario creare un metodo C# in grado di gestire questo messaggio. A tale scopo, viene creato un metodo C# e quindi lo si adorna con .ExportAttribute Modificare ViewControllere aggiungere il metodo seguente alla classe :

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

Eseguire l'applicazione. Dovrebbe ora comportarsi esattamente come in precedenza, ma usa un delegato debole anziché il delegato sicuro. A questo punto la procedura dettagliata è stata completata correttamente. È ora necessario avere una conoscenza di come creare e usare un progetto di associazione Xamarin.iOS.

Riepilogo

Questo articolo illustra il processo di creazione e uso di un progetto di associazione Xamarin.iOS. In primo luogo è stato illustrato come compilare una libreria esistente Objective-C in una libreria statica. È stato quindi illustrato come creare un progetto di associazione Xamarin.iOS e come usare Objective Sharpie per generare le definizioni API per la Objective-C libreria. È stato illustrato come aggiornare e modificare le definizioni di API generate per renderle adatte al consumo pubblico. Al termine del progetto di associazione Xamarin.iOS, è stato spostato l'uso di tale binding in un'applicazione Xamarin.iOS, con un focus sull'uso di delegati forti e delegati deboli.

Collegamenti correlati

• Librerie di binding Objective-C
• Dettagli associazione
• Guida di riferimento ai tipi di associazione
• Xamarin per Objective-C sviluppatori
• Linee guida per la progettazione del framework