Passo a passo: associar uma biblioteca do iOS Objective-C

  • Artigo
  • 26 minutos para o fim da leitura

Importante

No momento, estamos investigando o uso de associação personalizada na plataforma Xamarin. Faça esta pesquisa para informar os esforços futuros de desenvolvimento.

Este artigo fornece um passo a passo prático da criação de uma associação Xamarin.iOS para uma biblioteca existente Objective-C , InfColorPicker. Ele aborda tópicos como compilar uma biblioteca estática Objective-C , vinculá-la e usar a associação em um aplicativo Xamarin.iOS.

Ao trabalhar no iOS, você pode encontrar casos em que deseja consumir uma biblioteca de Objective-C terceiros. Nessas situações, você pode usar um Project de Associação Xamarin.iOS para criar uma associação C# que permitirá consumir a biblioteca em seus aplicativos Xamarin.iOS.

Geralmente, no ecossistema do iOS, você pode encontrar bibliotecas em três tipos:

  • Como um arquivo de biblioteca estática pré-compilado com .a extensão junto com seus cabeçalhos (arquivos.h). Por exemplo, a Biblioteca de Análise do Google
  • Como uma Estrutura pré-compilada. Essa é apenas uma pasta que contém a biblioteca estática, cabeçalhos e, às vezes, recursos adicionais com .framework extensão. Por exemplo, a Biblioteca AdMob do Google.
  • Como apenas arquivos de código-fonte. Por exemplo, uma biblioteca que contém arquivos Just .m e .h Objective C.

No primeiro e segundo cenário, já haverá uma Biblioteca Estática CocoaTouch pré-compilada, portanto, neste artigo, nos concentraremos no terceiro cenário. Lembre-se de que, antes de começar a criar uma associação, sempre verifique a licença fornecida com a biblioteca para garantir que você esteja livre para associá-la.

Este artigo fornece um passo a passo da criação de um projeto de associação usando o projeto código aberto InfColorPickerObjective-C como exemplo, no entanto, todas as informações neste guia podem ser adaptadas para uso com qualquer biblioteca de Objective-C terceiros. A biblioteca InfColorPicker fornece um controlador de exibição reutilizável que permite que o usuário selecione uma cor com base em sua representação de HSB, tornando a seleção de cores mais amigável.

Example of the InfColorPicker library running on iOS

Abordaremos todas as etapas necessárias para consumir essa API específica Objective-C no Xamarin.iOS:

  • Primeiro, criaremos uma Objective-C biblioteca estática usando o Xcode.
  • Em seguida, associaremos essa biblioteca estática ao Xamarin.iOS.
  • Em seguida, mostre como o Objective Sharpie pode reduzir a carga de trabalho gerando automaticamente algumas (mas não todas) das definições de API necessárias exigidas pela associação Xamarin.iOS.
  • Por fim, criaremos um aplicativo Xamarin.iOS que usa a associação.

O aplicativo de exemplo demonstrará como usar um representante forte para comunicação entre a API InfColorPicker e nosso código C#. Depois de vermos como usar um delegado forte, abordaremos como usar delegados fracos para executar as mesmas tarefas.

Requisitos

Este artigo pressupõe que você tenha alguma familiaridade com o Xcode e o Objective-C idioma e leu nossa documentação de associação Objective-C . Além disso, o seguinte é necessário para concluir as etapas apresentadas:

  • Xcode e SDK do iOS – o Xcode da Apple e a API do iOS mais recente precisam ser instalados e configurados no computador do desenvolvedor.
  • Ferramentas de Linha de Comando Xcode – As Ferramentas de Linha de Comando do Xcode devem ser instaladas para a versão atualmente instalada do Xcode (consulte abaixo para obter detalhes da instalação).
  • Visual Studio para Mac ou Visual Studio – a versão mais recente do Visual Studio para Mac ou Visual Studio deve ser instalada e configurada no computador de desenvolvimento. Um Apple Mac é necessário para desenvolver um aplicativo Xamarin.iOS e, ao usar Visual Studio você deve estar conectado a um host de build do Xamarin.iOS
  • A versão mais recente do Objective Sharpie – uma cópia atual da ferramenta Objective Sharpie baixada aqui. Se você já tiver o Objective Sharpie instalado, você poderá atualizá-lo para a versão mais recente usando o sharpie update

Instalando as Ferramentas de Linha de Comando do Xcode

Conforme indicado acima, usaremos as Ferramentas de Linha de Comando do Xcode (especificamente make e lipo) neste passo a passo. O make comando é um utilitário Unix muito comum que automatizará a compilação de programas executáveis e bibliotecas usando um makefile que especifica como o programa deve ser criado. O lipo comando é um utilitário de linha de comando do OS X para criar arquivos de várias arquiteturas; ele combinará vários .a arquivos em um arquivo que pode ser usado por todas as arquiteturas de hardware.

De acordo com o Build da Apple da linha de comando com documentação de perguntas frequentes do Xcode , no OS X 10.9 e superior, o painel Downloads da caixa de diálogo Preferências do Xcode não dá mais suporte às ferramentas de linha de comando de download.

Você precisará usar um dos seguintes métodos para instalar as ferramentas:

  • Instalar o Xcode – quando você instala o Xcode, ele vem empacotado com todas as ferramentas de linha de comando. Nos shims do OS X 10.9 (instalados), /usr/biné possível mapear qualquer ferramenta incluída na /usr/bin ferramenta correspondente dentro do Xcode. Por exemplo, o xcrun comando, que permite localizar ou executar qualquer ferramenta dentro do Xcode da linha de comando.

  • O aplicativo terminal – no aplicativo Terminal, você pode instalar as ferramentas de linha de comando executando o xcode-select --install comando:

    • Inicie o Aplicativo de Terminal.
    • Digite xcode-select --install e pressione Enter, por exemplo:
    Europa:~ kmullins$ xcode-select --install

    • Você será solicitado a instalar as ferramentas de linha de comando, clique no botão Instalar : Installing the command line tools

    • As ferramentas serão baixadas e instaladas dos servidores da Apple: Downloading the tools

  • Downloads para Desenvolvedores da Apple – O pacote Ferramentas de Linha de Comando está disponível na página Downloads para Desenvolvedores da Apple na Web. Faça logon com sua ID da Apple e, em seguida, pesquise e baixe as Ferramentas de Linha de Comando: Finding the Command Line Tools

Com as Ferramentas de Linha de Comando instaladas, estamos prontos para continuar com o passo a passo.

Passo a passo

Neste passo a passo, abordaremos as seguintes etapas:

  • Criar uma biblioteca estática – essa etapa envolve a criação de uma biblioteca estática do código InfColorPickerObjective-C . A biblioteca estática terá a extensão de .a arquivo e será inserida no assembly .NET do projeto de biblioteca.
  • Criar um Project de Associação Xamarin.iOS – depois que tivermos uma biblioteca estática, a usaremos para criar um projeto de associação Xamarin.iOS. O projeto de associação consiste na biblioteca estática que acabamos de criar e metadados na forma de código C# que explica como a Objective-C API pode ser usada. Esses metadados são comumente chamados de definições de API. Usaremos Objective Sharpie para nos ajudar a criar as definições de API.
  • Normalizar as Definições de API – Objective Sharpie faz um ótimo trabalho para nos ajudar, mas não pode fazer tudo. Discutiremos algumas alterações que precisamos fazer nas definições de API antes que elas possam ser usadas.
  • Usar a Biblioteca de Associação – Por fim, criaremos um aplicativo Xamarin.iOS para mostrar como usar nosso projeto de associação recém-criado.

Agora que entendemos quais etapas estão envolvidas, vamos passar para o resto do passo a passo.

Criando uma biblioteca estática

Se inspecionarmos o código para InfColorPicker no Github:

Inspect the code for InfColorPicker in Github

Podemos ver os três diretórios a seguir no projeto:

  • InfColorPicker – Este diretório contém o Objective-C código do projeto.
  • PickerSamplePad – Este diretório contém um exemplo iPad projeto.
  • PickerSamplePhone – Este diretório contém um exemplo iPhone projeto.

Vamos baixar o projeto InfColorPicker de GitHub e descompactá-lo no diretório de nossa escolha. Abrindo o destino Xcode para PickerSamplePhone o projeto, vemos a seguinte estrutura de projeto no Xcode Navigator:

The project structure in the Xcode Navigator

Esse projeto obtém a reutilização de código adicionando diretamente o código-fonte InfColorPicker (na caixa vermelha) em cada projeto de exemplo. O código do projeto de exemplo está dentro da caixa azul. Como esse projeto específico não nos fornece uma biblioteca estática, é necessário criar um projeto Xcode para compilar a biblioteca estática.

A primeira etapa é adicionar o código-fonte InfoColorPicker à Biblioteca Estática. Para isso, vamos fazer o seguinte:

  1. Inicie o Xcode.

  2. No menu Arquivo, selecione Novo>Project...:

    Screenshot shows Project selected from the New menu of the File menu.

  3. Selecione a Biblioteca de Estruturas&, o modelo da Biblioteca Estática cocoa touch e clique no botão Avançar:

    Select the Cocoa Touch Static Library template

  4. Insira InfColorPicker o nome do Project e clique no botão Avançar:

    Enter InfColorPicker for the Project Name

  5. Selecione um local para salvar o projeto e clique no botão OK .

  6. Agora, precisamos adicionar a origem do projeto InfColorPicker ao nosso projeto de biblioteca estática. Como o arquivo InfColorPicker.h já existe em nossa biblioteca estática (por padrão), o Xcode não nos permitirá substituí-lo. No Finder, navegue até o código-fonte InfColorPicker no projeto original que descompactamos de GitHub, copie todos os arquivos InfColorPicker e cole-os em nosso novo projeto de biblioteca estática:

    Copy all of the InfColorPicker files

  7. Retorne ao Xcode, clique com o botão direito do mouse na pasta InfColorPicker e selecione Adicionar arquivos a "InfColorPicker...":

    Adding files

  8. Na caixa de diálogo Adicionar Arquivos, navegue até os arquivos de código-fonte InfColorPicker que acabamos de copiar, selecione todos eles e clique no botão Adicionar :

    Select all and click the Add button

  9. O código-fonte será copiado em nosso projeto:

    The source code will be copied into the project

  10. No Xcode Project Navigator, selecione o arquivo InfColorPicker.m e comente as duas últimas linhas (devido à forma como essa biblioteca foi escrita, esse arquivo não é usado):

    Editing the InfColorPicker.m file

  11. Agora precisamos verificar se há estruturas exigidas pela biblioteca. Você pode encontrar essas informações no README ou abrindo um dos projetos de exemplo fornecidos. Este exemplo usa Foundation.frameworke UIKit.framework, portanto, CoreGraphics.framework vamos adicioná-los.

  12. Selecione as Fases de Build de destino > do InfColorPicker e expanda a seção Link Binary With Libraryes :

    Expand the Link Binary With Libraries section

  13. Use o + botão para abrir a caixa de diálogo, permitindo que você adicione as estruturas de quadros necessárias listadas acima:

    Add the required frames frameworks listed above

  14. A seção Link Binary With Libraryes agora deve se parecer com a imagem abaixo:

    The Link Binary With Libraries section

Neste momento estamos perto, mas ainda não terminamos. A biblioteca estática foi criada, mas precisamos criá-la para criar um binário Fat que inclua todas as arquiteturas necessárias para o dispositivo iOS e o simulador do iOS.

Criando um binário gordo

Todos os dispositivos iOS têm processadores alimentados pela arquitetura arm que se desenvolveram ao longo do tempo. Cada nova arquitetura adicionou novas instruções e outras melhorias, mantendo a compatibilidade com versões anteriores. Os dispositivos iOS têm conjuntos de instruções armv6, armv7, armv7s e arm64 – embora o armv6 não seja mais usado. O simulador do iOS não é alimentado pelo ARM e, em vez disso, é um simulador x86 e x86_64 habilitado. Isso significa que as bibliotecas devem ser fornecidas para cada conjunto de instruções.

Uma biblioteca fat é .a um arquivo que contém todas as arquiteturas com suporte.

Criar um binário gordo é um processo de três etapas:

  • Compile uma versão ARM 7 & ARM64 da biblioteca estática.
  • Compile uma versão x86 e x84_64 da biblioteca estática.
  • Use a lipo ferramenta de linha de comando para combinar as duas bibliotecas estáticas em uma.

Embora essas três etapas sejam bastante simples, talvez seja necessário repeti-las no futuro quando a Objective-C biblioteca receber atualizações ou se precisarmos de correções de bug. Se você decidir automatizar essas etapas, isso simplificará a manutenção futura e o suporte do projeto de associação do iOS.

Há muitas ferramentas disponíveis para automatizar essas tarefas - um script de shell, um ancinho, um xbuild e um make. Quando as ferramentas de Linha de Comando Xcode são instaladas, make também é instalada, de modo que é o sistema de build que será usado para este passo a passo. Aqui está um Makefile que você pode usar para criar uma biblioteca compartilhada de várias arquiteturas que funcionará em um dispositivo iOS e no simulador para qualquer biblioteca:

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

Insira os comandos Makefile no editor de texto sem formatação de sua escolha e atualize as seções com YOUR-PROJECT-NAME com o nome do projeto. Também é importante garantir que você cole exatamente as instruções acima, com as guias dentro das instruções preservadas.

Salve o arquivo com o nome Makefile no mesmo local que a Biblioteca Estática do Xcode InfColorPicker que criamos acima:

Save the file with the name Makefile

Abra o Aplicativo de Terminal em seu Mac e navegue até o local do makefile. Digite make no Terminal, pressione Enter e o Makefile será executado:

Sample makefile output

Ao executar make, você verá um monte de texto rolando. Se tudo funcionar corretamente, você verá as palavras BUILD SUCCEEDED e os libInfColorPicker-armv7.aarquivos e , libInfColorPicker-i386.a e libInfColorPickerSDK.a serão copiados para o mesmo local que o Makefile:

The libInfColorPicker-armv7.a, libInfColorPicker-i386.a and libInfColorPickerSDK.a files generated by the Makefile

Você pode confirmar as arquiteturas no binário fat usando o seguinte comando:

xcrun -sdk iphoneos lipo -info libInfColorPicker.a

Isso deve exibir o seguinte:

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

Neste ponto, concluímos a primeira etapa de nossa associação do iOS criando uma biblioteca estática usando o Xcode e as ferramentas make de Linha de Comando Xcode e lipo. Vamos para a próxima etapa e usar Objective-Sharpie para automatizar a criação das associações de API para nós.

Criar um Project de associação Xamarin.iOS

Antes de podermos usar Objective-Sharpie para automatizar o processo de associação, precisamos criar um Project de Associação Xamarin.iOS para abrigar as Definições de API (que usaremos Objective-Sharpie para nos ajudar a criar) e criar a associação C# para nós.

Vamos fazer o seguinte:

  1. Inicie Visual Studio para Mac.

  2. No menu Arquivo, selecione NewSolution>...:

    Starting a new solution

  3. Na caixa de diálogo Nova Solução, selecione Project de Associaçãodo LibraryiOS>:

    Select iOS Binding Project

  4. Clique no botão Avançar.

  5. Insira "InfColorPickerBinding" como o nome do Project e clique no botão Criar para criar a solução:

    Enter InfColorPickerBinding as the Project Name

A solução será criada e dois arquivos padrão serão incluídos:

The solution structure in the Solution Explorer

  • ApiDefinition.cs - Esse arquivo conterá os contratos que definem como Objective-C as API serão encapsuladas em C#.
  • Structs.cs - Esse arquivo conterá quaisquer estruturas ou valores de enumeração exigidos pelas interfaces e delegados.

Trabalharemos com esses dois arquivos mais adiante no passo a passo. Primeiro, precisamos adicionar a biblioteca InfColorPicker ao projeto de associação.

Incluindo a Biblioteca Estática no Project de Associação

Agora que temos nosso Project de Associação base pronto, precisamos adicionar a biblioteca Fat Binary que criamos acima para a biblioteca InfColorPicker.

Siga estas etapas para adicionar a biblioteca:

  1. Clique com o botão direito do mouse na pasta Referências Nativas no Painel de Soluções e selecione Adicionar Referências Nativas:

    Add Native References

  2. Navegue até o Binário gordo que fizemos anteriormente (libInfColorPickerSDK.a) e pressione o botão Abrir :

    Select the libInfColorPickerSDK.a file

  3. O arquivo será incluído no projeto:

    Including a file

Quando o arquivo . a é adicionado ao projeto, o Xamarin.iOS definirá automaticamente a Ação de Build do arquivo como ObjcBindingNativeLibrary e criará um arquivo especial chamado libInfColorPickerSDK.linkwith.cs.

Esse arquivo contém o LinkWith atributo que informa ao Xamarin.iOS como lidar com a biblioteca estática que acabamos de adicionar. O conteúdo desse arquivo é mostrado no seguinte snippet de código:

using ObjCRuntime;

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

O LinkWith atributo identifica a biblioteca estática do projeto e alguns sinalizadores importantes do vinculador.

A próxima coisa que precisamos fazer é criar as definições de API para o projeto InfColorPicker. Para fins deste passo a passo, usaremos Objective Sharpie para gerar o arquivo ApiDefinition.cs.

Usando Objective Sharpie

Objective Sharpie é uma ferramenta de linha de comando (fornecida pelo Xamarin) que pode ajudar na criação das definições necessárias para associar uma biblioteca de terceiros Objective-C ao C#. Nesta seção, usaremos Objective Sharpie para criar o ApiDefinition.cs inicial para o projeto InfColorPicker.

Para começar, vamos baixar o arquivo do instalador objective sharpie conforme detalhado neste guia. Execute o instalador e siga todos os prompts na tela do assistente de instalação para instalar o Objective Sharpie em nosso computador de desenvolvimento.

Depois de instalarmos o Objective Sharpie com êxito, vamos iniciar o aplicativo Terminal e inserir o seguinte comando para obter ajuda em todas as ferramentas que ele fornece para ajudar na associação:

sharpie -help

Se executarmos o comando acima, a seguinte saída será gerada:

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

Para este passo a passo, usaremos as seguintes ferramentas do Objective Sharpie:

  • xcode – Essas ferramentas nos dão informações sobre nossa instalação atual do Xcode e as versões das APIs iOS e Mac que instalamos. Usaremos essas informações mais tarde quando gerarmos nossas associações.
  • bind - Usaremos essa ferramenta para analisar os arquivos .h no projeto InfColorPicker nos arquivos ApiDefinition.cs e StructsAndEnums.cs iniciais.

Para obter ajuda em uma ferramenta específica do Objective Sharpie, insira o nome da ferramenta e a opção -help . Por exemplo, sharpie xcode -help retorna a seguinte saída:

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.

Antes de iniciarmos o processo de associação, precisamos obter informações sobre nossos SDKs atuais instalados inserindo o seguinte comando no Terminal 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

No exemplo acima, podemos ver que temos o iphoneos9.3 SDK instalado em nosso computador. Com essas informações em vigor, estamos prontos para analisar os arquivos de projeto .h InfColorPicker no ApiDefinition.cs inicial e StructsAndEnums.cs no projeto InfColorPicker.

Insira o seguinte comando no aplicativo Terminal:

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

Onde [full-path-to-project] está o caminho completo para o diretório em que o arquivo de projeto Xcode InfColorPicker está localizado em nosso computador e [iphone-os] é o SDK do iOS que instalamos, conforme observado pelo sharpie xcode -sdks comando. Observe que, neste exemplo, passamos *.h como um parâmetro, que inclui todos os arquivos de cabeçalho neste diretório - normalmente você NÃO deve fazer isso, mas, em vez disso, leia cuidadosamente os arquivos de cabeçalho para encontrar o arquivo .h de nível superior que faz referência a todos os outros arquivos relevantes e basta passá-lo para Objective Sharpie.

Dica

Para o -scope argumento, passe a pasta que tem os cabeçalhos que você deseja associar. Sem o argumento, o -scope Objective Sharpie tentará gerar associações para quaisquer cabeçalhos do SDK do iOS importados, por exemplo #import <UIKit.h>, resultando em um arquivo de definições enorme que provavelmente gerará erros ao compilar o projeto de associação. Com o -scope conjunto de argumentos, o Objective Sharpie não gerará associações para nenhum cabeçalho fora da pasta com escopo.

A seguinte saída será gerada no terminal:

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 os arquivos InfColorPicker.enums.cs e InfColorPicker.cs serão criados em nosso diretório:

The InfColorPicker.enums.cs and InfColorPicker.cs files

Abra ambos os arquivos no projeto de associação que criamos acima. Copie o conteúdo do arquivo InfColorPicker.cs e cole-o no arquivo ApiDefinition.cs , substituindo o bloco de código existente namespace ... pelo conteúdo do arquivo InfColorPicker.cs (deixando as using instruções intactas):

The InfColorPickerControllerDelegate file

Normalizar as definições de API

O Objective Sharpie às vezes tem um problema de tradução Delegates, portanto, precisaremos modificar a definição da InfColorPickerControllerDelegate interface e substituir a [Protocol, Model] linha pelo seguinte:

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

Para que a definição se pareça com:

The definition

Em seguida, fazemos a mesma coisa com o conteúdo do InfColorPicker.enums.cs arquivo, copiando e colando-os StructsAndEnums.cs no arquivo deixando as using instruções intactas:

The contents the StructsAndEnums.cs file

Você também pode descobrir que Objective Sharpie anotou a associação com [Verify] atributos. Esses atributos indicam que você deve verificar se Objective Sharpie fez a coisa correta comparando a associação com a declaração C/Objective-C original (que será fornecida em um comentário acima da declaração associada). Depois de verificar as associações, você deve remover o atributo de verificação. Para obter mais informações, consulte o guia Verificar .

Neste ponto, nosso projeto de associação deve estar concluído e pronto para compilar. Vamos criar nosso projeto de associação e garantir que acabamos sem erros:

Crie o projeto de associação e verifique se não há erros

Usando a associação

Siga estas etapas para criar um aplicativo de iPhone de exemplo para usar a Biblioteca de Associação do iOS criada acima:

  1. Criar Project do Xamarin.iOS – adicione um novo projeto Xamarin.iOS chamado InfColorPickerSample à solução, conforme mostrado nas seguintes capturas de tela:

    Adding a Single View App

    Setting the Identifier

  2. Adicionar referência ao Project de associação – atualize o projeto InfColorPickerSample para que ele tenha uma referência ao projeto InfColorPickerBinding:

    Adding Reference to the Binding Project

  3. Crie o iPhone Interface do Usuário – Clique duas vezes no arquivo MainStoryboard.storyboard no projeto InfColorPickerSample para editá-lo no Designer do iOS. Adicione um botão ao modo de exibição e chame-o ChangeColorButton, conforme mostrado no seguinte:

    Adding a Button to the view

  4. Adicione o InfColorPickerView.xib – a biblioteca InfColorPicker Objective-C inclui um arquivo .xib . O Xamarin.iOS não incluirá esse .xib no projeto de associação, o que causará erros em tempo de execução em nosso aplicativo de exemplo. A solução alternativa para isso é adicionar o arquivo .xib ao nosso projeto Xamarin.iOS. Selecione o projeto Xamarin.iOS, clique com o botão direito do mouse e selecione Adicionar > Arquivos e adicione o arquivo .xib , conforme mostrado na captura de tela a seguir:

    Add the InfColorPickerView.xib

  5. Quando solicitado, copie o arquivo .xib no projeto.

Em seguida, vamos dar uma olhada rápida nos Protocolos e como Objective-C os manipulamos na associação e no código C#.

Protocolos e Xamarin.iOS

Em Objective-C, um protocolo define métodos (ou mensagens) que podem ser usados em determinadas circunstâncias. Conceitualmente, eles são muito semelhantes às interfaces em C#. Uma grande diferença entre um Objective-C protocolo e uma interface C# é que os protocolos podem ter métodos opcionais – métodos que uma classe não precisa implementar. Objective-C usa a @optional palavra-chave usada para indicar quais métodos são opcionais. Para obter mais informações sobre protocolos , consulte Eventos, Protocolos e Delegados.

InfColorPickerController tem um desses protocolos, mostrado no snippet de código abaixo:

@protocol InfColorPickerControllerDelegate

@optional

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

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

@end

Esse protocolo é usado por InfColorPickerController para informar aos clientes que o usuário escolheu uma nova cor e que o InfColorPickerController foi concluído. Objective Sharpie mapeou esse protocolo, conforme mostrado no seguinte snippet de código:

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

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

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

Quando a biblioteca de associação for compilada, o Xamarin.iOS criará uma classe base abstrata chamada InfColorPickerControllerDelegate, que implementa essa interface com métodos virtuais.

Há duas maneiras de implementar essa interface em um aplicativo Xamarin.iOS:

  • Delegado forte – o uso de um delegado forte envolve a criação de uma classe C# que subclasse InfColorPickerControllerDelegate e substitui os métodos apropriados. InfColorPickerController usará uma instância dessa classe para se comunicar com seus clientes.
  • Delegado Fraco – Um delegado fraco é uma técnica ligeiramente diferente que envolve a criação de um método público em alguma classe (como InfColorPickerSampleViewController) e, em seguida, expor esse método ao InfColorPickerDelegate protocolo por meio de um Export atributo.

Delegados fortes fornecem intellisense, segurança de tipo e melhor encapsulamento. Por essas razões, você deve usar delegados fortes onde puder, em vez de um delegado fraco.

Neste passo a passo, discutiremos ambas as técnicas: primeiro implementar um delegado forte e, em seguida, explicar como implementar um delegado fraco.

Implementando um delegado forte

Conclua o aplicativo Xamarin.iOS usando um delegado forte para responder à colorPickerControllerDidFinish: mensagem:

Subclasse InfColorPickerControllerDelegate – Adicionar uma nova classe ao projeto chamado ColorSelectedDelegate. Edite a classe para que ela tenha o seguinte código:

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);
    }
  }
}

O Xamarin.iOS associará o Objective-C delegado criando uma classe base abstrata chamada InfColorPickerControllerDelegate. Subclasse esse tipo e substitua o ColorPickerControllerDidFinish método para acessar o valor da ResultColor propriedade de InfColorPickerController.

Criar uma instância de ColorSelectedDelegate – Nosso manipulador de eventos precisará de uma instância do ColorSelectedDelegate tipo que criamos na etapa anterior. Edite a classe InfColorPickerSampleViewController e adicione a seguinte variável de instância à classe:

ColorSelectedDelegate selector;

Inicializar a variável ColorSelectedDelegate – para garantir que selector seja uma instância válida, atualize o método ViewDidLoadViewController para corresponder ao seguinte snippet:

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

Implementar o método HandleTouchUpInsideWithStrongDelegate – Em seguida, implemente o manipulador de eventos para quando o usuário tocar em ColorChangeButton. Edite ViewControllere adicione o seguinte método:

using InfColorPicker;
...

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

Primeiro, obtemos uma instância por meio de InfColorPickerController um método estático e chamamos essa instância de nosso delegado forte por meio da propriedade InfColorPickerController.Delegate. Essa propriedade foi gerada automaticamente para nós pela Objective Sharpie. Por fim, chamamos PresentModallyOverViewController para mostrar o modo de exibição InfColorPickerSampleViewController.xib para que o usuário possa selecionar uma cor.

Executar o aplicativo – Neste momento, terminamos com todo o nosso código. Se você executar o aplicativo, poderá alterar a cor da tela de fundo, InfColorColorPickerSampleView conforme mostrado nas seguintes capturas de tela:

Running the Application

Parabéns! Neste ponto, você criou e vinculou com êxito uma Objective-C biblioteca para uso em um aplicativo Xamarin.iOS. Em seguida, vamos aprender a usar delegados fracos.

Implementando um delegado fraco

Em vez de subclasse de uma classe associada ao Objective-C protocolo de um delegado específico, o Xamarin.iOS também permite implementar os métodos de protocolo em qualquer classe derivada, NSObjectdecorando seus métodos com o ExportAttributee fornecendo os seletores apropriados. Ao adotar essa abordagem, você atribui uma instância de sua classe à WeakDelegate propriedade em vez de à Delegate propriedade. Um delegado fraco oferece a flexibilidade de colocar sua classe delegada em uma hierarquia de herança diferente. Vamos ver como implementar e usar um delegado fraco em nosso aplicativo Xamarin.iOS.

Criar Manipulador de Eventos para TouchUpInside – vamos criar um novo manipulador de eventos para o TouchUpInside evento do botão Alterar Cor do Plano de Fundo. Esse manipulador preencherá a mesma função que o HandleTouchUpInsideWithStrongDelegate manipulador que criamos na seção anterior, mas usará um delegado fraco em vez de um delegado forte. Edite a classe ViewControllere adicione o seguinte método:

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

Atualizar ViewDidLoad – Devemos alterar ViewDidLoad para que ele use o manipulador de eventos que acabamos de criar. Edite ViewController e altere ViewDidLoad para se parecer com o seguinte snippet de código:

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

Manipule a colorPickerControllerDidFinish: Mensagem – quando a mensagem for concluída, o ViewController iOS enviará a mensagem colorPickerControllerDidFinish: para .WeakDelegate Precisamos criar um método C# que possa lidar com essa mensagem. Para fazer isso, criamos um método C# e, em seguida, adornamos-o com o ExportAttribute. Edite ViewControllere adicione o seguinte método à classe:

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

Execute o aplicativo. Agora ele deve se comportar exatamente como antes, mas está usando um delegado fraco em vez do delegado forte. Neste ponto, você concluiu com êxito este passo a passo. Agora você deve ter uma compreensão de como criar e consumir um projeto de associação Xamarin.iOS.

Resumo

Este artigo percorreu o processo de criação e uso de um projeto de associação Xamarin.iOS. Primeiro, discutimos como compilar uma biblioteca existente Objective-C em uma biblioteca estática. Em seguida, abordamos como criar um projeto de associação Xamarin.iOS e como usar o Objective Sharpie para gerar as definições de API para a Objective-C biblioteca. Discutimos como atualizar e ajustar as definições de API geradas para torná-las adequadas para consumo público. Depois que o projeto de associação Xamarin.iOS foi concluído, passamos a consumir essa associação em um aplicativo Xamarin.iOS, com foco no uso de delegados fortes e delegados fracos.