Android java library jar

Binding a .JAR

We’re currently investigating custom binding usage on the Xamarin platform. Please take this survey to inform future development efforts.

This walkthrough provides step-by-step instructions for creating a Xamarin.Android Java Bindings Library from an Android .JAR file.

Overview

The Android community offers many Java libraries that you may want to use in your app. These Java libraries are often packaged in .JAR (Java Archive) format, but you can package a .JAR it in a Java Bindings Library so that its functionality is available to Xamarin.Android apps. The purpose of the Java Bindings library is to make the APIs in the .JAR file available to C# code through automatically-generated code wrappers.

Xamarin tooling can generate a Bindings Library from one or more input .JAR files. The Bindings Library (.DLL assembly) contains the following:

The contents of the original .JAR file(s).

Managed Callable Wrappers (MCW), which are C# types that wrap corresponding Java types within the .JAR file(s).

The generated MCW code uses JNI (Java Native Interface) to forward your API calls to the underlying .JAR file. You can create bindings libraries for any .JAR file that was originally targeted to be used with Android (note that Xamarin tooling does not currently support the binding of non-Android Java libraries). You can also elect to build the Bindings Library without including the contents of the .JAR file so that the DLL has a dependency on the .JAR at runtime.

In this guide, we’ll step through the basics of creating a Bindings Library for a single .JAR file. We’ll illustrate with an example where everything goes right – that is, where no customization or debugging of bindings is required. Creating Bindings Using Metadata offers an example of a more advanced scenario where the binding process is not entirely automatic and some amount of manual intervention is required. For an overview of Java library binding in general (with a basic code example), see Binding a Java Library.

Walkthrough

In the following walkthrough, we’ll create a Bindings Library for Picasso, a popular Android .JAR that provides image loading and caching functionality. We will use the following steps to bind picasso-2.x.x.jar to create a new .NET assembly that we can use in a Xamarin.Android project:

Create a new Java Bindings Library project.

Add the .JAR file to the project.

Set the appropriate build action for the .JAR file.

Choose a target framework that the .JAR supports.

Build the Bindings Library.

Once we’ve created the Bindings Library, we’ll develop a small Android app that demonstrates our ability to call APIs in the Bindings Library. In this example, we want to access methods of picasso-2.x.x.jar:

After we generate a Bindings Library for picasso-2.x.x.jar, we can call these methods from C#. For example:

Creating the Bindings Library

Before commencing with the steps below, please download picasso-2.x.x.jar.

First, create a new Bindings Library project. In Visual Studio for Mac or Visual Studio, create a new Solution and select the Android Bindings Library template. (The screenshots in this walkthrough use Visual Studio, but Visual Studio for Mac is very similar.) Name the Solution JarBinding:

The template includes a Jars folder where you add your .JAR(s) to the Bindings Library project. Right-click the Jars folder and select Add > Existing Item:

Navigate to the picasso-2.x.x.jar file downloaded earlier, select it and click Add:

Verify that the picasso-2.x.x.jar file was successfully added to the project:

When you create a Java Bindings library project, you must specify whether the .JAR is to be embedded in the Bindings Library or packaged separately. To do that, you specify one of the following build actions:

EmbeddedJar – the .JAR will be embedded in the Bindings Library.

InputJar – the .JAR will be kept separate from the Bindings Library.

Typically, you use the EmbeddedJar build action so that the .JAR is automatically packaged into the bindings library. This is the simplest option – Java bytecode in the .JAR is converted into Dex bytecode and is embedded (along with the Managed Callable Wrappers) into your APK. If you want to keep the .JAR separate from the bindings library, you can use the InputJar option; however, you must ensure that the .JAR file is available on the device that runs your app.

Set the build action to EmbeddedJar:

Next, open the project Properties to configure the Target Framework. If the .JAR uses any Android APIs, set the Target Framework to the API level that the .JAR expects. Typically, the developer of the .JAR file will indicate which API level (or levels) that the .JAR is compatible with. (For more information about the Target Framework setting and Android API levels in general, see Understanding Android API Levels.)

Set the target API level for your Bindings Library (in this example, we are using API level 19):

Finally, build the Bindings Library. Although some warning messages may be displayed, the Bindings Library project should build successfully and produce an output .DLL at the following location: JarBinding/bin/Debug/JarBinding.dll

Using the Bindings Library

To consume this .DLL in your Xamarin.Android app, do the following:

Add a reference to the Bindings Library.

Make calls into the .JAR through the Managed Callable Wrappers.

In the following steps, we’ll create a minimal app that uses the Bindings Library to download and display an image in an ImageView ; the «heavy lifting» is done by the code that resides in the .JAR file.

First, create a new Xamarin.Android app that consumes the Bindings Library. Right-click the Solution and select Add New Project; name the new project BindingTest. We’re creating this app in the same Solution as the Bindings Library in order to simplify this walkthrough; however, the app that consumes the Bindings Library could, instead, reside in a different Solution:

Right-click the References node of the BindingTest project and select Add Reference. :

Check the JarBinding project created earlier and click OK:

Open the References node of the BindingTest project and verify that the JarBinding reference is present:

Modify the BindingTest layout (Main.axml) so that it has a single ImageView :

Add the following using statement to MainActivity.cs – this makes it possible to easily access the methods of the Java-based Picasso class that resides in the Bindings Library:

Modify the OnCreate method so that it uses the Picasso class to load an image from a URL and display it in the ImageView :

Compile and run the BindingTest project. The app will startup, and after a short delay (depending on network conditions), it should download and display an image similar to the following screenshot:

Congratulations! You’ve successfully bound a Java library .JAR and used it in your Xamarin.Android app.

Summary

In this walkthrough, we created a Bindings Library for a third-party .JAR file, added the Bindings Library to a minimal test app, and then ran the app to verify that our C# code can call Java code residing in the .JAR file.

Источник

Создание и публикация библиотеки Android

Russian (Pусский) translation by Ilya Nikov (you can also view the original English article)

Введение

Наша жизнь в качестве разработчиков Android была бы намного сложнее, если бы не все эти сторонние библиотеки, которые мы хотели бы включить в наши проекты. В этом уроке вы узнаете, как проникнуть в сообщество разработчиков, создавая и публикуя свои собственные библиотеки Android, которые люди могут легко добавлять и использовать в своих проектах.

1. Создание библиотеки Android

Если ваша библиотека будет состоять только из классов Java, упаковка их как JAR и распространение ее с использованием хостинга файлов, возможно, самый быстрый и простой способ поделиться ею. Если вам нужно было создать ее из консоли, достаточно было бы выполнить следующую команду:

Однако этот учебник показывает, как работать с более сложными библиотеками, которые содержат не только классы Java, но также различные типы файлов и ресурсов XML. Такие библиотеки создаются как модули библиотеки Android и обычно упаковываются как файлы AAR.

Давайте создадим простую библиотеку Android, которая предлагает пользовательский View для разработчиков, которые его используют.

Шаг 1: добавьте новый модуль

Для начала добавьте в проект новый модуль Android, выбрав Новый> Новый модуль в меню Файл. Вам будет показан следующий экран, который предлагает множество вариантов:

Выберите Библиотека Android и нажмите Далее. В следующей форме введите имя своей библиотеки и нажмите Далее. Я буду называть эту библиотеку mylittlelibrary.

На последнем экране выберите Не добавлять активность и нажмите Готово.

Теперь у вашего проекта будет два модуля: один для приложения и один для библиотеки. Вот как выглядит его структура:

Шаг 2. Создание макета.

Создайте новый формат XML, щелкнув правой кнопкой мыши папку res вашего библиотечного модуля и выбрав New> XML> Layout XML File. Назовите его my_view.xml.

Чтобы этот учебник был простым, мы создадим пользовательский View , в котором есть два виджета TextView внутри LinearLayout . После добавления некоторого текста в виджеты TextView XML-файл макета должен выглядеть так:

Шаг 3. Создание класса Java

Создайте новый класс Java и назовите его MyView.java. Обязательно поместите этот файл в каталог src библиотечного модуля, а не в модуль приложения.

Чтобы этот класс работал как View , сделайте его подклассом класса LinearLayout . Android Studio предложит добавить в класс несколько конструкторов. После их добавления новый класс должен выглядеть следующим образом:

Как вы можете видеть, теперь у нас есть два конструктора. Чтобы избежать добавления кода инициализации для каждого конструктора, вызовите метод с именем initialize из каждого конструктора. Добавьте следующий код к каждому конструктору:

В методе initialize вызовите inflate , чтобы связать макет, который мы создали на предыдущем шаге с классом.

2. Использование библиотеки локально

Теперь, когда библиотека готова, давайте воспользуемся ею в модуле app того же проекта, чтобы убедиться, что проблем нет. Для этого добавьте ее как compile зависимость в файле build.gradle модуля app:

Создайте новый класс Java MainActivity внутри модуля приложения. Сделайте его подклассом класса Activity и переопределите его метод onCreate .

Внутри метода onCreate создайте экземпляр пользовательского представления, используя его конструктор. Передайте его методу setContentView , чтобы он заполнил все пространство экрана Activity :

Теперь ваша Activity готова. Добавив его в манифест приложения, создайте проект и разверните приложение на устройстве Android. После запуска приложения вы сможете увидеть пользовательский вид.

3. Публикация вашей библиотеки на Bintray

Bintray — популярная платформа, которую вы можете использовать для публикации Android-библиотек. Она бесплатная и простая в использовании.

Начните с создания учетной записи на Bintray. После входа в свою учетную запись вы увидите, что у вас уже есть шесть репозиториев. Вы можете использовать один из них или создать новый репозиторий. Для этого урока я буду использовать репозиторий, называемый maven, который является репозиторием Maven.

Перейдите на страницу своего профиля и нажмите кнопку Изменить. На следующей странице щелкните ссылку API Key, чтобы просмотреть свой ключ API.

Запомните ключ, потому что вам понадобится его аутентификация при использовании плагина Bintray.

Шаг 1: добавьте необходимые плагины

Чтобы взаимодействовать с Bintray в Android Studio, вы должны включить плагин Bintray в dependencies файла build.gradle вашего проекта.

Поскольку вы загружаете библиотеку в репозиторий Maven, вы также должны добавить плагин Maven, как показано ниже.

Шаг 2: Примените плагины

Откройте файл build.gradle вашего библиотечного модуля и добавьте следующий код, чтобы применить плагины, добавленные нами на предыдущем шаге.

Шаг 3: укажите детали POM

Плагин Bintray будет искать файл POM при загрузке библиотеки. Несмотря на то, что плагин Maven генерирует его для вас, вы должны указать значение тега groupId и значение тега version самостоятельно. Для этого используйте переменные group и version в вашем файле gradle.

Если вы знакомы с Maven, и вам интересно, почему мы не указали значение тега artifactId , это потому, что плагин Maven по умолчанию использует имя вашей библиотеки как artifactId .

Шаг 4: Создание JAR исходников

Чтобы соответствовать стандартам Maven, ваша библиотека также должна иметь JAR-файл, содержащий исходные файлы библиотеки. Чтобы сгенерировать JAR-файл, создайте новую задачу Jar , generateSourcesJar и укажите местоположение исходных файлов, используя функцию from .

Шаг 5: Создание JAR Javadoc JAR

Также рекомендуется, чтобы ваша библиотека имела JAR-файл, содержащий его Javadocs. Поскольку в настоящее время у вас нет Javadocs, создайте новую задачу Javadoc , generateJavadocs, чтобы сгенерировать их. Используйте переменную source , чтобы указать расположение исходных файлов. Вы также должны обновить переменную classpath , чтобы задача могла находить классы, принадлежащие Android SDK. Вы можете сделать это, добавив к нему возвращаемое значение метода android.getBootClasspath .

Затем, чтобы создать JAR из Javadocs, создайте задачу Jar , generateJavadocsJar и передайте свойство destinationDir для generateJavaDocs в его функцию from. Ваша новая задача должна выглядеть так:

Чтобы задача generateJavadocsJar запускалась только после завершения задачи generateJavadocs , добавьте следующий фрагмент кода, который использует метод dependOn для порядка задач:

Шаг 6: Включите сгенерированные файлы JAR

Чтобы включить исходные файлы JAR и Javadoc в список артефактов, которые будут загружены в репозиторий Maven, вы должны добавить имена своих задач в configuration с именем archives. Для этого используйте следующий фрагмент кода:

Шаг 7: Запуск задач

Настало время запустить задачи, которые мы создали на предыдущих шагах. Откройте окно Gradle Projects и найдите задачу с именем install.

Дважды щелкните его, чтобы выполнить задачи, связанные с библиотечным модулем. По завершении работы у вас будет все, что вам нужно, чтобы опубликовать вашу библиотеку, действительный файл POM, файл AAR, источник JAR и JAR Javadocs.

Шаг 8: Настройте плагин Bintray

Чтобы настроить плагин, вы должны использовать замыкание bintray в файле Gradle. Сначала выполните аутентификацию с использованием переменных user и key , соответствующих вашему имени пользователя Bintray и API-интерфейсу соответственно.

В Bintray ваша библиотека будет находиться внутри пакета Bintray. Вы должны предоставить подробную информацию об этом, используя интуитивно названные параметры repo , name , licenses , и vcsUrl для замыкания pkg . Если пакет не существует, он будет для вас автоматически создан.

Когда вы загружаете файлы в Bintray, они будут связаны с версией пакета Bintray. Следовательно, pkg должен содержать замыкание version , для свойства name которого задано уникальное имя. Кроме того, вы также можете предоставить описание, дату выпуска и тег Git с использованием параметров desc , release и vcsTag .

Наконец, чтобы указать файлы, которые должны быть загружены, установите значение параметра configuration в archives.

Это пример конфигурации:

Шаг 9: Загрузка файлов с помощью плагина Bintray

Откройте окно Gradle Projects снова и найдите задачу bintrayUpload. Дважды щелкните его, чтобы начать загрузку файлов.

По завершении задачи откройте браузер, чтобы открыть страницу с информацией о пакете Bintray. Вы увидите уведомление, в котором говорится, что у вас есть четыре неопубликованных файла. Чтобы опубликовать эти файлы, нажмите ссылку Опубликовать.

4. Использование библиотеки из Bintray

Ваша библиотека теперь доступна как пакет Bintray. После того, как вы поделитесь URL-адресом своего репозитория Maven, вместе с идентификатором группы, идентификатором артефакта и номером версии, любой разработчик может получить доступ к вашей библиотеке. Например, чтобы использовать созданную библиотеку, разработчикам пришлось бы включить следующий фрагмент кода:

Обратите внимание, что разработчик должен явно включать ваш репозиторий в список repositories , прежде чем добавлять библиотеку в качестве compile зависимости.

5. Добавление библиотеки в JCenter

По умолчанию Android Studio ищет библиотеки в репозитории JCenter. Если вы включите свою библиотеку в репозиторий JCenter, разработчикам не нужно будет добавлять что-либо в свой список repositories .

Чтобы добавить свою библиотеку в JCenter, откройте браузер и зайдите на страницу сведений о пакете Bintray. Нажмите кнопку Добавить в JCenter.

Затем вы попадете на страницу, которая позволит вам составить сообщение. Вы можете использовать поле Комментарии, чтобы дополнительно указать какие-либо сведения о библиотеке.

Нажмите кнопку Отправить, чтобы начать процесс ревью Bintray. В течение дня или двух люди из Bintray свяжут вашу библиотеку с репозиторием JCenter, и вы сможете увидеть ссылку на JCenter на странице сведений о вашем пакете.

Любой разработчик теперь может использовать вашу библиотеку, не меняя список repositories .

Заключение

В этом уроке вы узнали, как создать простой модуль библиотеки Android и опубликовать его как в своем собственном репозитории Maven, так и в репозитории JCenter. По пути вы также научились создавать и выполнять различные типы задач gradle.

Чтобы узнать больше о Bintray, посетите руководство пользователя Bintray.

Источник