Migrar uma associação para a API unificada

  • Artigo

Este artigo aborda as etapas necessárias para atualizar um projeto de vinculação Xamarin existente para oferecer suporte às APIs unificadas para aplicativos Xamarin.IOS e Xamarin.Mac.

Visão geral

A partir de 1º de fevereiro de 2015, a Apple exige que todos os novos envios para o iTunes e a Mac App Store sejam aplicativos de 64 bits. Como resultado, qualquer novo aplicativo Xamarin.iOS ou Xamarin.Mac precisará usar a nova API unificada em vez das APIs Classic MonoTouch e MonoMac existentes para oferecer suporte a 64 bits.

Além disso, qualquer projeto de vinculação do Xamarin também deve oferecer suporte às novas APIs unificadas a serem incluídas em um projeto Xamarin.iOS ou Xamarin.Mac de 64 bits. Este artigo abordará as etapas necessárias para atualizar um projeto de vinculação existente para usar a API unificada.

Requisitos

O seguinte é necessário para concluir as etapas apresentadas neste artigo:

  • Visual Studio para Mac - A versão mais recente do Visual Studio para Mac instalada e configurada no computador de desenvolvimento.
  • Apple Mac - Um Mac Apple é necessário para criar projetos de vinculação para iOS e Mac.

Projetos de vinculação não são suportados no Visual Studio em um computador Windows.

Modificar as instruções Using

As APIs unificadas tornam mais fácil do que nunca compartilhar código entre Mac e iOS, além de permitir que você ofereça suporte a aplicativos de 32 e 64 bits com o mesmo binário. Ao remover os prefixos MonoMac e MonoTouch dos namespaces, o compartilhamento mais simples é obtido em projetos de aplicativos Xamarin.Mac e Xamarin.iOS.

Como resultado, precisaremos modificar qualquer um de nossos contratos vinculativos (e outros .cs arquivos em nosso projeto de vinculação) para remover os prefixos MonoMac e MonoTouch de nossas using declarações.

Por exemplo, considerando o seguinte usando instruções em um contrato vinculante:

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

Retiraríamos o prefixo MonoTouch resultando no seguinte:

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

Novamente, precisaremos fazer isso para qualquer .cs arquivo em nosso projeto de vinculação. Com essa alteração, a próxima etapa é atualizar nosso projeto de vinculação para usar os novos tipos de dados nativos.

Para obter mais informações sobre a API unificada, consulte a documentação da API unificada. Para obter mais informações sobre o suporte a aplicativos de 32 e 64 bits e informações sobre estruturas, consulte a documentação Considerações sobre plataformas de 32 e 64 bits.

Atualizar para tipos de dados nativos

Objective-C mapeia o NSInteger tipo de dados para int32_t sistemas de 32 bits e para sistemas de int64_t 64 bits. Para corresponder a esse comportamento, a nova API unificada substitui os usos anteriores de (que no .NET é definido como sempre sendoSystem.Int32) para um novo tipo de int dados: System.nint.

Junto com o novo nint tipo de dados, a API Unificada introduz os nuint e nfloat tipos, para mapeamento para os NSUInteger e CGFloat tipos também.

Diante do exposto acima, precisamos revisar nossa API e garantir que qualquer instância do NSInteger, NSUInteger e CGFloat que mapeamos anteriormente para int, uint e float seja atualizada para o novo nint, nuint e nfloat tipos.

Por exemplo, dada uma Objective-C definição de método de:

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

Se o contrato vinculante anterior tivesse a seguinte definição:

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

Atualizaríamos a nova vinculação para ser:

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

Se estivermos mapeando para uma biblioteca de terceiros de versão mais recente do que a que tínhamos inicialmente vinculado, precisamos revisar os arquivos de cabeçalho da .h biblioteca e ver se alguma chamada explícita de saída para int, int32_t, uint32_tunsigned int, ou float foi atualizada para ser um NSInteger, NSUInteger ou um CGFloat. Em caso afirmativo, as mesmas modificações no nint, nuint e nfloat tipos também precisarão ser feitas em seus mapeamentos.

Para saber mais sobre essas alterações de tipo de dados, consulte o documento Tipos nativos .

Atualizar os tipos CoreGraphics

Os tipos de dados de ponto, tamanho e retângulo usados usam CoreGraphics 32 ou 64 bits, dependendo do dispositivo em que estão sendo executados. Quando o Xamarin vinculou originalmente as APIs do iOS e do Mac, usamos estruturas de dados existentes que correspondiam aos tipos de dados em System.Drawing (RectangleF por exemplo).

Devido aos requisitos para oferecer suporte a 64 bits e aos novos tipos de dados nativos, os seguintes ajustes precisarão ser feitos no código existente ao chamar CoreGraphic métodos:

  • CGRect - Use CGRect em vez de ao definir regiões retangulares de RectangleF ponto flutuante.
  • CGSize - Use CGSize em vez de ao definir tamanhos de SizeF ponto flutuante (largura e altura).
  • CGPoint - Use CGPoint em vez de ao definir um local de PointF ponto flutuante (coordenadas X e Y).

Diante do exposto acima, precisaremos revisar nossa API e garantir que qualquer instância do CGRect, CGSize ou CGPoint que foi anteriormente vinculada ao RectangleF, SizeF ou PointF seja alterada para o tipo CGRectnativo , CGSize ou CGPoint diretamente.

Por exemplo, dado um Objective-C inicializador de:

- (id)initWithFrame:(CGRect)frame;

Se nossa vinculação anterior incluísse o seguinte código:

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

Atualizaríamos esse código para:

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

Com todas as alterações de código agora em vigor, precisamos modificar nosso projeto de vinculação ou fazer com que o arquivo seja vinculado às APIs Unificadas.

Modificar o projeto de vinculação

Como etapa final para atualizar nosso projeto de vinculação para usar as APIs Unificadas, precisamos modificar o MakeFile que usamos para criar o projeto ou o Tipo de Projeto Xamarin (se estivermos vinculando de dentro do Visual Studio para Mac) e instruir o btouch a vincular às APIs Unificadas em vez das Clássicas.

Atualizando um MakeFile

Se estivermos usando um makefile para criar nosso projeto de vinculação em um .DLL Xamarin, precisaremos incluir a --new-style opção de linha de comando e chamar btouch-native em vez de btouch.

Assim, dado o seguinte 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

Precisamos mudar de chamada btouch para btouch-native, então ajustamos nossa definição de macro da seguinte maneira:

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

Atualizaríamos a chamada e btouch adicionaríamos a --new-style opção da seguinte maneira:

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

Agora podemos executar o nosso MakeFile como normal para construir a nova versão de 64 bits da nossa API.

Atualizando um tipo de projeto de vinculação

Se estivermos usando um Modelo de Projeto de Vinculação do Visual Studio para Mac para criar nossa API, precisaremos atualizar para a nova versão da API Unificada do Modelo de Projeto de Vinculação. A maneira mais fácil de fazer isso é iniciar um novo Projeto de Vinculação de API Unificada e copiar todo o código e as configurações existentes.

Faça o seguinte:

  1. Inicie o Visual Studio para Mac.

  2. Selecione Arquivo>Nova>Solução...

  3. Na caixa de diálogo Nova Solução, selecione Projeto>de Vinculação do iOS da API>Unificada do iOS:

    Na caixa de diálogo Nova Solução, selecione iOS / API unificada / Projeto de vinculação do iOS

  4. Na caixa de diálogo 'Configurar seu novo projeto', insira um Nome para o novo projeto de vinculação e clique no botão OK .

  5. Inclua a versão de 64 bits da Objective-C biblioteca para a qual você criará associações.

  6. Copie o código-fonte do seu projeto de vinculação de API clássica de 32 bits existente (como o ApiDefinition.cs e StructsAndEnums.cs arquivos).

  7. Faça as alterações acima observadas nos arquivos de código-fonte.

Com todas essas alterações em vigor, você pode criar a nova versão de 64 bits da API como faria com a versão de 32 bits.

Resumo

Neste artigo, mostramos as alterações que precisam ser feitas em um projeto de vinculação Xamarin existente para oferecer suporte às novas APIs unificadas e dispositivos de 64 bits e as etapas necessárias para criar a nova versão compatível de 64 bits de uma API.