Share via

Migrieren einer Bindung zu Unified API

  • Artikel

In diesem Artikel werden die Schritte behandelt, die erforderlich sind, um ein vorhandenes Xamarin Binding Project zu aktualisieren, um die Unified APIs für Xamarin.IOS- und Xamarin.Mac-Anwendungen zu unterstützen.

Übersicht

Ab dem 1. Februar 2015 erfordert Apple, dass alle neuen Übermittlungen an iTunes und mac App Store 64-Bit-Anwendungen sein müssen. Daher muss jede neue Xamarin.iOS- oder Xamarin.Mac-Anwendung die neue Unified-API anstelle der vorhandenen klassischen MonoTouch- und MonoMac-APIs verwenden, um 64 Bit zu unterstützen.

Darüber hinaus muss jedes Xamarin-Bindungsprojekt auch die neuen Unified-APIs unterstützen, die in einem 64-Bit-Xamarin.iOS- oder Xamarin.Mac-Projekt enthalten sein sollen. In diesem Artikel werden die Schritte behandelt, die erforderlich sind, um ein vorhandenes Bindungsprojekt für die Verwendung der Unified API zu aktualisieren.

Anforderungen

Die folgenden Schritte sind erforderlich, um die in diesem Artikel beschriebenen Schritte auszuführen:

  • Visual Studio für Mac – Die neueste Version von Visual Studio für Mac auf dem Entwicklungscomputer installiert und konfiguriert.
  • Apple Mac – Ein Apple Mac ist erforderlich, um Bindungsprojekte für iOS und Mac zu erstellen.

Bindungsprojekte werden in Visual Studio auf einem Windows-Computer nicht unterstützt.

Ändern der Using-Anweisungen

Die Unified-APIs erleichtern die Gemeinsame Nutzung von Code zwischen Mac und iOS sowie die Unterstützung von 32- und 64-Bit-Anwendungen mit derselben Binärdatei. Durch das Ablegen der Präfixe MonoMac und MonoTouch aus den Namespaces wird die einfachere Freigabe in Xamarin.Mac- und Xamarin.iOS-Anwendungsprojekten erreicht.

Daher müssen wir einen unserer verbindlichen Verträge (und andere .cs Dateien in unserem verbindlichen Projekt) ändern, um die Präfixe MonoMac und MonoTouch aus unseren using Erklärungen zu entfernen.

Beispiel: In Anbetracht der folgenden Verwendungsanweisungen in einem verbindlichen Vertrag:

using System;
using System.Drawing;
using MonoTouch.Foundation;
using MonoTouch.UIKit;
using MonoTouch.ObjCRuntime;

Wir würden das MonoTouch Präfix entfernen, was zu folgendem Ergebnis führt:

using System;
using System.Drawing;
using Foundation;
using UIKit;
using ObjCRuntime;

Auch hier müssen wir dies für jede .cs Datei in unserem Bindungsprojekt tun. Mit dieser Änderung besteht der nächste Schritt darin, unser Bindungsprojekt so zu aktualisieren, dass die neuen nativen Datentypen verwendet werden.

Weitere Informationen zur Unified API finden Sie in der Unified API-Dokumentation . Weitere Hintergrundinformationen zur Unterstützung von 32- und 64-Bit-Anwendungen und Informationen zu Frameworks finden Sie in der Dokumentation zu 32- und 64-Bit-Plattformüberlegungen .

Aktualisieren auf systemeigene Datentypen

Objective-C ordnet den NSInteger Datentyp int32_t auf 32-Bit-Systemen und auf 64-Bit-Systemen zu int64_t . Um diesem Verhalten zu entsprechen, ersetzt die neue Unified-API die vorherigen Verwendungen ( int die in .NET als immer definiert sind System.Int32) in einen neuen Datentyp: System.nint.

Zusammen mit dem neuen nint Datentyp führt die Unified-API die und nfloat die nuint Typen ein, um auch die Zuordnung zu den NSUInteger Und CGFloat Typen zu erfahren.

In Anbetracht der oben genannten, müssen wir unsere API überprüfen und sicherstellen, dass jede Instanz von , und die wir zuvor zugeordnet inthaben, uint und float auf die neuen nintUnd nfloatnuint Typen aktualisiert werden.CGFloatNSUIntegerNSInteger

Beispiel: Eine Objective-C Methodendefinition von:

-(NSInteger) add:(NSInteger)operandUn and:(NSInteger) operandDeux;

Wenn der vorherige bindungsverbindliche Vertrag die folgende Definition hatte:

[Export("add:and:")]
int Add(int operandUn, int operandDeux);

Wir würden die neue Bindung so aktualisieren, dass:

[Export("add:and:")]
nint Add(nint operandUn, nint operandDeux);

Wenn wir eine neuere Version 3-Drittanbieterbibliothek zuordnen als mit dem, was wir ursprünglich verknüpft hatten, müssen wir die .h Headerdateien für die Bibliothek überprüfen und überprüfen, ob alle beendenden, expliziten Aufrufe von int, int32_t, , oder floatunsigned intuint32_t ein Upgrade auf ein NSInteger, NSUInteger oder ein CGFloatUpgrade durchgeführt wurden. Wenn ja, müssen die gleichen Änderungen an den nintnuint zugehörigen Zuordnungen vorgenommen werden, und nfloat die Typen müssen ebenfalls vorgenommen werden.

Weitere Informationen zu diesen Datentypänderungen finden Sie im Dokument " Native Types ".

Aktualisieren der CoreGraphics-Typen

Die Datentypen Punkt, Größe und Rechteck, die je nach Gerät, auf dem sie ausgeführt werden, mit CoreGraphics 32 oder 64 Bit verwendet werden. Wenn Xamarin die iOS- und Mac-APIs ursprünglich gebunden hat, haben wir vorhandene Datenstrukturen verwendet, die mit den Datentypen System.Drawing übereinstimmen (RectangleF z. B. ).

Aufgrund der Anforderungen zur Unterstützung von 64 Bits und den neuen systemeigenen Datentypen müssen beim Aufrufen CoreGraphic von Methoden die folgenden Anpassungen an vorhandenem Code vorgenommen werden:

  • CGRect – Verwenden Sie CGRect anstelle der Definition rechteckiger RectangleF Gleitkommabereiche.
  • CGSize – Verwenden Sie CGSize anstelle der Definition von SizeF Gleitkommagrößen (Breite und Höhe).
  • CGPoint – Verwenden Sie CGPoint anstelle der PointF Definition einer Gleitkommaposition (X- und Y-Koordinaten).

Im Vorstehenden müssen wir unsere API überprüfen und sicherstellen, dass jede Instanz von , oder die zuvor an den systemeigenen Typ CGRectCGSizeCGPoint gebunden SizeFRectangleFoder PointF direkt geändert wurde.CGPointCGSizeCGRect

Beispiel: Initialisierer Objective-C von:

- (id)initWithFrame:(CGRect)frame;

Wenn unsere vorherige Bindung den folgenden Code enthält:

[Export ("initWithFrame:")]
IntPtr Constructor (RectangleF frame);

Wir würden diesen Code aktualisieren auf:

[Export ("initWithFrame:")]
IntPtr Constructor (CGRect frame);

Da jetzt alle Codeänderungen vorgenommen wurden, müssen wir unser Bindungsprojekt ändern oder eine Datei zum Binden an die Unified-APIs vornehmen.

Ändern des Bindungsprojekts

Als letzten Schritt zum Aktualisieren unseres Bindungsprojekts für die Verwendung der Unified-APIs müssen wir entweder das MakeFile Projekt oder den Xamarin-Projekttyp (wenn wir innerhalb von Visual Studio für Mac binden) ändern und btouch anweisen, eine Bindung an die Unified-APIs anstelle der klassischen APIs auszuführen.

Aktualisieren einer MakeFile-Datei

Wenn wir eine Makefile verwenden, um unser Bindungsprojekt in einem Xamarin-.DLL zu erstellen, müssen wir die --new-style Befehlszeilenoption und den Aufruf btouch-native anstelle von btouch.

In Anbetracht der folgenden Punkte MakeFile:

BINDDIR=/src/binding
XBUILD=/Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild
PROJECT_ROOT=XMBindingLibrarySample
PROJECT=$(PROJECT_ROOT)/XMBindingLibrarySample.xcodeproj
TARGET=XMBindingLibrarySample
BTOUCH=/Developer/MonoTouch/usr/bin/btouch

all: XMBindingLibrary.dll

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

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

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

libXMBindingLibrarySampleUniversal.a: libXMBindingLibrarySample-armv7.a libXMBindingLibrarySample-i386.a libXMBindingLibrarySample-arm64.a
	lipo -create -output $@ $^

XMBindingLibrary.dll: AssemblyInfo.cs XMBindingLibrarySample.cs extras.cs libXMBindingLibrarySampleUniversal.a
	$(BTOUCH) -unsafe -out:$@ XMBindingLibrarySample.cs -x=AssemblyInfo.cs -x=extras.cs --link-with=libXMBindingLibrarySampleUniversal.a,libXMBindingLibrarySampleUniversal.a

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

Wir müssen von Anrufen btouch zu btouch-nativewechseln, damit wir unsere Makrodefinition wie folgt anpassen würden:

BTOUCH=/Developer/MonoTouch/usr/bin/btouch-native

Wir aktualisieren den Aufruf und btouch fügen die --new-style Option wie folgt hinzu:

XMBindingLibrary.dll: AssemblyInfo.cs XMBindingLibrarySample.cs extras.cs libXMBindingLibrarySampleUniversal.a
	$(BTOUCH) -unsafe --new-style -out:$@ XMBindingLibrarySample.cs -x=AssemblyInfo.cs -x=extras.cs --link-with=libXMBindingLibrarySampleUniversal.a,libXMBindingLibrarySampleUniversal.a

Wir können jetzt unsere MakeFile als normal ausführen, um die neue 64-Bit-Version unserer API zu erstellen.

Aktualisieren eines Bindungsprojekttyps

Wenn wir eine Visual Studio für Mac Bindungsprojektvorlage verwenden, um unsere API zu erstellen, müssen wir auf die neue Unified API-Version der Bindungsprojektvorlage aktualisieren. Die einfachste Möglichkeit besteht darin, ein neues Unified API Binding Project zu starten und den gesamten vorhandenen Code und die vorhandenen Einstellungen zu kopieren.

Gehen Sie folgendermaßen vor:

  1. Starten Sie Visual Studio für Mac.

  2. >Datei neue>Lösung auswählen...

  3. Wählen Sie im Dialogfeld "Neue Lösung" die Option "iOS>Unified API>iOS Binding Project" aus:

    Wählen Sie im Dialogfeld

  4. Geben Sie im Dialogfeld "Neues Projekt konfigurieren" einen Namen für das neue Bindungsprojekt ein, und klicken Sie auf die Schaltfläche "OK ".

  5. Schließen Sie die 64-Bit-Version der Objective-C Bibliothek ein, für die Sie Bindungen erstellen möchten.

  6. Kopieren Sie den Quellcode aus Ihrem vorhandenen 32-Bit-Klassischen API-Bindungsprojekt (z. B. die ApiDefinition.cs dateien).StructsAndEnums.cs

  7. Nehmen Sie die oben genannten Änderungen an den Quellcodedateien vor.

Mit all diesen Änderungen können Sie die neue 64-Bit-Version der API wie die 32-Bit-Version erstellen.

Zusammenfassung

In diesem Artikel haben wir die Änderungen gezeigt, die an einem vorhandenen Xamarin Binding Project vorgenommen werden müssen, um die neuen Unified APIs und 64-Bit-Geräte zu unterstützen, sowie die Schritte, die zum Erstellen der neuen 64-Bit-kompatiblen Version einer API erforderlich sind.