Associação de um .AAR
Importante
No momento, estamos investigando o uso de vinculação personalizada na plataforma Xamarin. Por favor, faça esta pesquisa para informar os futuros esforços de desenvolvimento.
Este passo a passo fornece instruções passo a passo para criar uma biblioteca de ligações Java Xamarin.Android a partir de um Android . Arquivo AAR.
Visão geral
O arquivo Android (. AAR) é o formato de arquivo para bibliotecas Android. Ano. O arquivo AAR é um arquivo .ZIP que contém o seguinte:
- Código Java compilado
- IDs de recurso
- Recursos
- Metadados (por exemplo, declarações de atividade, permissões)
Neste guia, abordaremos os conceitos básicos da criação de uma Biblioteca de Ligações para um único arquivo . Arquivo AAR. Para obter uma visão geral da vinculação de bibliotecas Java em geral (com um exemplo de código básico), consulte Vinculando uma biblioteca Java.
Importante
Um projeto de vinculação só pode incluir um arquivo . Arquivo AAR. Se o . A RAA depende de outros . AAR, então essas dependências devem estar contidas em seu próprio projeto de vinculação e, em seguida, referenciadas.
Passo a passo
Criaremos uma Biblioteca de Ligações para um exemplo de arquivo morto do Android que foi criado no Android Studio, textanalyzer.aar. Este. O AAR contém uma TextCounter
classe com métodos estáticos que contam o número de vogais e consoantes em uma cadeia de caracteres. Além disso, textanalyzer.aar contém um recurso de imagem para ajudar a exibir os resultados da contagem.
Usaremos as etapas a seguir para criar uma Biblioteca de Ligações a partir do . Arquivo AAR:
Crie um novo projeto Java Bindings Library.
Adicione um único arquivo . AAR para o projeto. Um projeto de vinculação pode conter apenas um único arquivo . AAR.
Defina a ação de compilação apropriada para o . Arquivo AAR.
Escolha uma estrutura de destino que o . Suporte AAR.
Crie a Biblioteca de Ligações.
Depois de criarmos a Biblioteca de Ligações, desenvolveremos um pequeno aplicativo Android que solicita ao usuário uma cadeia de caracteres de texto, chamadas . Métodos AAR para analisar o texto, recupera a imagem do . AAR e exibe os resultados junto com a imagem.
O aplicativo de exemplo acessará a TextCounter
classe de textanalyzer.aar:
package com.xamarin.textcounter;
public class TextCounter
{
...
public static int numVowels (String text) { ... };
...
public static int numConsonants (String text) { ... };
...
}
Além disso, este aplicativo de exemplo recuperará e exibirá um recurso de imagem empacotado em textanalyzer.aar:
Este recurso de imagem reside em res/drawable/monkey.png em textanalyzer.aar.
Criando a biblioteca de ligações
Antes de começar com as etapas abaixo, baixe o arquivo de arquivo textanalyzer.aar Android de exemplo:
Crie um novo projeto de Biblioteca de Ligações começando com o modelo Biblioteca de Ligações do Android. Você pode usar o Visual Studio para Mac ou o Visual Studio (as capturas de tela abaixo mostram o Visual Studio, mas o Visual Studio para Mac é muito semelhante). Nomeie a solução como AarBinding:
O modelo inclui uma pasta Jars onde você adiciona seu arquivo . AAR(s) para o projeto Biblioteca de Ligações. Clique com o botão direito do mouse na pasta Jars e selecione Adicionar > item existente:
Navegue até o arquivo textanalyzer.aar baixado anteriormente, selecione-o e clique em Adicionar:
Verifique se o arquivo textanalyzer.aar foi adicionado com êxito ao projeto:
Defina a Ação de compilação para textanalyzer.aar como
AndroidLibrary
. No Visual Studio para Mac, clique com o botão direito do mouse em textanalyzer.aar para definir a Ação de Compilação. No Visual Studio, a Ação de Criação pode ser definida no painel Propriedades ):Abra as Propriedades do projeto para configurar a Estrutura de Destino. Se o . O AAR usa qualquer API do Android, defina o Target Framework para o nível de API que o . A AAR espera. (Para obter mais informações sobre a configuração do Target Framework e os níveis de API do Android em geral, consulte Noções básicas sobre os níveis de API do Android.)
Defina o nível de API de destino para sua Biblioteca de Ligações. Neste exemplo, estamos livres para usar o nível de API de plataforma mais recente (nível de API 23) porque nosso analisador de texto não tem uma dependência de APIs Android:
Crie a Biblioteca de Ligações. O projeto Bindings Library deve ser compilado com êxito e produzir uma .DLL de saída no seguinte local: AarBinding/bin/Debug/AarBinding.dll
Usando a Biblioteca de Ligações
Para consumir esse .DLL em seu aplicativo Xamarin.Android, você deve primeiro adicionar uma referência à Biblioteca de Ligações. Use as seguintes etapas:
Estamos criando este aplicativo na mesma Solução que a Biblioteca de Ligações para simplificar este passo a passo. (O aplicativo que consome a Biblioteca de Ligações também pode residir em uma Solução diferente.) Crie um novo aplicativo Xamarin.Android: clique com o botão direito do mouse na Solução e selecione Adicionar Novo Projeto. Nomeie o novo projeto BindingTest:
Clique com o botão direito do mouse no nó Referências do projeto BindingTest e selecione Adicionar referência...:
Selecione o projeto AarBinding criado anteriormente e clique em OK:
Abra o nó Referências do projeto BindingTest para verificar se a referência AarBinding está presente:
Se desejar exibir o conteúdo do projeto Biblioteca de vinculação, clique duas vezes na referência para abri-la no Pesquisador de Objetos. Você pode ver o conteúdo mapeado do Com.Xamarin.Textcounter
namespace (mapeado a partir do pacote Java com.xamarin.textanalyzezr
) e visualizar os TextCounter
membros da classe:
A captura de tela acima destaca os dois TextAnalyzer
métodos que o aplicativo de exemplo chamará: NumConsonants
(que encapsula o método Java numConsonants
subjacente) e NumVowels
(que encapsula o método Java numVowels
subjacente).
Acessar. Tipos de AAR
Depois de adicionar uma referência ao seu aplicativo que aponte para a Biblioteca de Vinculação, você poderá acessar os tipos Java no . AAR como você acessaria os tipos de C# (graças aos wrappers de C#). O código do aplicativo C# pode chamar TextAnalyzer
métodos conforme ilustrado neste exemplo:
using Com.Xamarin.Textcounter;
...
int numVowels = TextCounter.NumVowels (myText);
int numConsonants = TextCounter.NumConsonants (myText);
No exemplo acima, estamos chamando métodos estáticos na TextCounter
classe. No entanto, você também pode instanciar classes e chamar métodos de instância. Por exemplo, se o seu arquivo . O AAR encapsula uma classe chamada Employee
que tem o método buildFullName
de instância, você pode instanciá-la MyClass
e usá-la como visto aqui:
var employee = new Com.MyCompany.MyProject.Employee();
var name = employee.BuildFullName ();
As etapas a seguir adicionam código ao aplicativo para que ele solicite texto ao usuário, use TextCounter
para analisar o texto e exiba os resultados.
Substitua o layout BindingTest (Main.axml) com o seguinte XML. Este layout tem um para entrada de EditText
texto e dois botões para iniciar contagens de vogais e consoantes:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation ="vertical"
android:layout_width ="fill_parent"
android:layout_height ="fill_parent" >
<TextView
android:text ="Text to analyze:"
android:textSize ="24dp"
android:layout_marginTop ="30dp"
android:layout_gravity ="center"
android:layout_width ="wrap_content"
android:layout_height ="wrap_content" />
<EditText
android:id ="@+id/input"
android:text ="I can use my .AAR file from C#!"
android:layout_marginTop ="10dp"
android:layout_gravity ="center"
android:layout_width ="300dp"
android:layout_height ="wrap_content"/>
<Button
android:id ="@+id/vowels"
android:layout_marginTop ="30dp"
android:layout_width ="240dp"
android:layout_height ="wrap_content"
android:layout_gravity ="center"
android:text ="Count Vowels" />
<Button
android:id ="@+id/consonants"
android:layout_width ="240dp"
android:layout_height ="wrap_content"
android:layout_gravity ="center"
android:text ="Count Consonants" />
</LinearLayout>
Substitua o conteúdo do MainActivity.cs pelo código a seguir. Como visto neste exemplo, os manipuladores de eventos button chamam métodos encapsulados TextCounter
que residem no . AAR e use notificações do sistema para exibir os resultados. Observe a using
instrução para o namespace da biblioteca vinculada (neste caso, Com.Xamarin.Textcounter
):
using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using Android.Views.InputMethods;
using Com.Xamarin.Textcounter;
namespace BindingTest
{
[Activity(Label = "BindingTest", MainLauncher = true, Icon = "@drawable/icon")]
public class MainActivity : Activity
{
InputMethodManager imm;
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.Main);
imm = (InputMethodManager)GetSystemService(Context.InputMethodService);
var vowelsBtn = FindViewById<Button>(Resource.Id.vowels);
var consonBtn = FindViewById<Button>(Resource.Id.consonants);
var edittext = FindViewById<EditText>(Resource.Id.input);
edittext.InputType = Android.Text.InputTypes.TextVariationPassword;
edittext.KeyPress += (sender, e) =>
{
imm.HideSoftInputFromWindow(edittext.WindowToken, HideSoftInputFlags.NotAlways);
e.Handled = true;
};
vowelsBtn.Click += (sender, e) =>
{
int count = TextCounter.NumVowels(edittext.Text);
string msg = count + " vowels found.";
Toast.MakeText (this, msg, ToastLength.Short).Show ();
};
consonBtn.Click += (sender, e) =>
{
int count = TextCounter.NumConsonants(edittext.Text);
string msg = count + " consonants found.";
Toast.MakeText (this, msg, ToastLength.Short).Show ();
};
}
}
}
Compile e execute o projeto BindingTest . O aplicativo será iniciado e apresentará a captura de tela à esquerda (o EditText
é inicializado com algum texto, mas você pode tocar nele para alterá-lo). Quando você toca em CONTAR VOGAIS, uma notificação do sistema exibe o número de vogais, conforme mostrado à direita:
Tente tocar no botão CONTAR CONSOANTES . Além disso, você pode modificar a linha de texto e tocar nesses botões novamente para testar diferentes contagens de vogais e consoantes.
Acessar. Recursos do AAR
As ferramentas do Xamarin mesclam os dados do R do . AAR na classe Resource do seu aplicativo. Como resultado, você pode acessar o . Recursos de AAR do seu layout (e do code-behind) da mesma forma que você acessaria os recursos que estão no caminho Recursos do seu projeto.
Para acessar um recurso de imagem, use o nome Resource.Drawable para a imagem compactada dentro do . AAR. Por exemplo, você pode fazer referência a image.png no . Arquivo AAR usando @drawable/image
:
<ImageView android:src="@drawable/image" ... />
Você também pode acessar layouts de recursos que residem no . AAR. Para fazer isso, use o nome Resource.Layout para o layout empacotado dentro do . AAR. Por exemplo:
var a = new ArrayAdapter<string>(this, Resource.Layout.row_layout, ...);
O exemplo textanalyzer.aar contém um arquivo de imagem que reside em res/drawable/monkey.png. Vamos acessar este recurso de imagem e usá-lo em nosso aplicativo de exemplo:
Edite o layout BindingTest (Main.axml) e adicione um ImageView
ao final do LinearLayout
contêiner. Isso ImageView
exibe a imagem encontrada em @drawable/monkey, esta imagem será carregada da seção de recursos do textanalyzer.aar:
...
<ImageView
android:src ="@drawable/monkey"
android:layout_marginTop ="40dp"
android:layout_width ="200dp"
android:layout_height ="200dp"
android:layout_gravity ="center" />
</LinearLayout>
Compile e execute o projeto BindingTest . O aplicativo será iniciado e apresentará a captura de tela à esquerda – quando você tocar em CONTAR CONSOANTES, os resultados serão exibidos como mostrado à direita:
Parabéns! Você vinculou com êxito uma biblioteca Java . AAR!
Resumo
Neste passo a passo, criamos uma Biblioteca de Ligações para um arquivo . AAR, adicionou a Biblioteca de Ligações a um aplicativo de teste mínimo e executou o aplicativo para verificar se nosso código C# pode chamar o código Java residente no . Arquivo AAR. Além disso, estendemos o aplicativo para acessar e exibir um recurso de imagem que reside no . Arquivo AAR.