Share via

Associação de um .AAR

  • Artigo

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:

  1. Crie um novo projeto Java Bindings Library.

  2. Adicione um único arquivo . AAR para o projeto. Um projeto de vinculação pode conter apenas um único arquivo . AAR.

  3. Defina a ação de compilação apropriada para o . Arquivo AAR.

  4. Escolha uma estrutura de destino que o . Suporte AAR.

  5. 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:

Imagem do macaco Xamarin

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:

  1. 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:

    Criar projeto AarBindings

  2. 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:

    Adicionar item existente

  3. Navegue até o arquivo textanalyzer.aar baixado anteriormente, selecione-o e clique em Adicionar:

    Adicionar textanalayzer.aar

  4. Verifique se o arquivo textanalyzer.aar foi adicionado com êxito ao projeto:

    O arquivo textanalyzer.aar foi adicionado

  5. 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 ):

    Definindo a ação de compilação textanalyzer.aar para AndroidLibrary

  6. 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:

    Definindo o nível de destino para a API 23

  7. 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:

  1. 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:

    Criar novo projeto BindingTest

  2. Clique com o botão direito do mouse no nó Referências do projeto BindingTest e selecione Adicionar referência...:

    Clique em Adicionar referência

  3. Selecione o projeto AarBinding criado anteriormente e clique em OK:

    Verifique o projeto de vinculação do AAR

  4. Abra o nó Referências do projeto BindingTest para verificar se a referência AarBinding está presente:

    AarBinding está listado em Referências

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:

Exibindo o Pesquisador de Objetos

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 buildFullNamede 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:

Capturas de tela da execução do BindingTest

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:

BindingTest exibindo contagem de consoantes

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.