Android create aar library

Generate an Android Archive( AAR) Using Android Studio and Add to an Android Project

This article provides Information for creating AAR for an Android Library module and use It with another android Project.

I have posted an article for creating an Android Library module in an Android Project and use that with the UI app module.

Please see the article if you need to know about creating the Library module in Android Project.

Create an Android Library and use in your Android Project

This blog is providing information that why modular code structure is important and how the android library can play an…

In this article, I will explain how we can generate the Android Archive( AAR) file for an Android Library module and Use that in different Android projects so that we can understand the Library creation can really save our redevelopment time cost by using the same module in different projects.

I will use Android Studio 4.0.2 and the same Project mention in the above-attached article.

I have created a project and a Library module It is shown below.

It is mentioned that I have created a Library Module named as currentTimeLib and I am using that module successfully within the project, now I will generate the AAR file and I will Import the AAR file into a different Android Project.

If you already know about creating the Library module then you can follow the steps directly.

If you want to Implement it then either complete the previous article (Click here) or pull the code from Git and try on that(Click here).

Please follow the steps>>

Step1: Start the Android Studio and open the project where you want to generate the AAR file.

Step2: Click the Gradle option in right most corner of android studio.

Step3: You will see the App name in the window, please unfold the options in the sequence shown below.

Источник

Building an AAR Library in Android Studio

Purpose of AAR

Library reuse has long been available in Java based applications through Java Archive (.jar) files. Android AAR files build upon this concept to allow you to package not only the source code but also the libraries self contained Android resources. The library can have its own manifest and resources and can also optionally provide assets, NDK built libraries, proguard configuration and even its own custom lint filters. This is all bundled into a zip archive that can be published to a repository for your team (or the world!) to get easy access from a Gradle build.

AAR File Format

• /AndroidManifest.xml (mandatory)
• /classes.jar (mandatory)
• /res/ (mandatory)
• /R.txt (mandatory)
• /assets/ (optional)
• /libs/*.jar (optional)
• /jni/ /*.so (optional)
• /proguard.txt (optional)
• /lint.jar (optional)

Creating an AAR library project

The good news is creating an AAR library is easy and Android Studio will do all the hard work for you.

Figure 1: Create an Android Library

1. Start by selecting New Module… from the File menu
2. Select Android Library as the module to be created (see Figure 1)
3. Step through the process of using a template for the creation of your library much like creating a new project

One key difference in the created library and an Android application will be the libraries Gradle build script includes apply plugin: ‘com.android.library’ instead of apply plugin: ‘com.android.application’.

When you build your project the AAR file will automatically be assembled and placed in these folders (Android Studio 1.0+)

Using AAR

You have a few choices as to how to include your AAR library in your project:

• Publish to a external Maven repository
• Publish to a local repository
• Access from a local folder

While Gradle can be used to directly publish to repositories such as Maven Central, this article doesn’t cover publishing your AAR file to Maven repositories.

To include your AAR library as a dependency from a local folder:

1. Copy the AAR file into the libs folder in your project. Create this folder if it doesn’t exist. It needs to be located in the same folder as your application Gradle build file, not the top level project folder.

2. Declare the libs folder as a dependency repository in your application Gradle script.

The Gradle flatDir repository declaration allows you to declare a file system directory that is a repository for dependencies for the project. In the example above I am using the libs folder which needs to be located relative to the location of the build script. The name of this folder does not have to be libs and it is also possible to declare multiple fileDir folders in the one project.

3. Declare your AAR library as a dependency:

Manifest Merging

Earlier in this article we noted that the AndroidManifest.xml is a compulsory item in an AAR library. When an app includes your AAR library the manifest must be merged with that of the app, as there will be only one manifest included in an APK.

Merging manifests can quickly get messy when multiple conflicting manifests are all merged. The android tools user guide to manifest mergers is the best resource available to explain all the ins and outs of how the merge will happen and how you can control the merge.

The most basic rule of the merge is the order of priorities given to different manifests. From most influential to least:

1. Product flavors and build types specific manifest files.
2. Main manifest file for the application.
3. Library manifest files.

So you can see your Library manifest sits at the bottom of the pecking order.

Most of the time this merging will happen like magic, without the need for intervention. If issues arise in the manifest merge there are a couple of places to start looking in order to track down the issue. The first place to check is the final outputted manifest file. The next place to check is the manifest merge report (which is saved into the app\build\outputs\logs\ folder of your project). The format and contents of the logging in the merge report is explained here.

References

AAR File Format

Manifest merging user guide

Источник

How to Build *.so Library Files into AAR Bundle in Android Studio

When making third party libraries and SDKs for Android development, you could build so files, jar files, or aar files. I prefer providing aar files for distribution since aar file is a simple zip file which includes so files, jar files, and other resources.

What’s inside aar file?

• /AndroidManifest.xml (mandatory)
• /classes.jar (mandatory)
• /res/ (mandatory)
• /R.txt (mandatory)
• /assets/ (optional)
• /libs/*.jar (optional)
• /jni//*.so (optional)
• /proguard.txt (optional)
• /lint.jar (optional)

The structure of aar is similar to apk.

How to create a basic aar file?

Click File > New > New Module and select Android Library:

Comparing build.gradle files, you will see the main difference is that the plugin name for aar is “com.android.library”, whereas the plugin name for application is “com.android.application”.

How to package prebuilt .so library files into .aar file?

The simplest way to add so files into an aar file is to create a folder jniLibs under src/main. And then copy *.so files into the folder:

After building the module, you can open build/outputs/aar/*.aar to verify **jni//*.so**.

How to automatically build native code into .aar file in Android Studio?

Let’s do something more complicated:

1. Create a static library *.a with command line tool.
2. Write JNI code and create a shared library *.so in Android Studio with the static library.

Static library libtwolib-first.a

Referring to the NDK sample two-libs, quickly create libtwolib-first.a with ndk-build.

Makefile Android.mk:

Header file first.h:

Source file first.c:

Shared library libdbr.so and barcode.aar bundle

To enable NDK integration for building JNI applications, use the new experimental plugin of Gradle instead of the original plugin.

Create a new module barcode with JNI folder and dbr.c:

Copy libtwolib-first.a and first.h to the jni folder.

Create BarcodeReader.java:

Modify build.gradle:

A better way to link prebuilt library:

Build debug and release version with Gradle:

You can download more NDK Gradle project samples from https://github.com/googlesamples/android-ndk.git

How to import .aar file to an Android project?

Create an empty Android project.

Click File > New > New Module and choose Import .JAR/.AAR Package:

Click Next to specify the file name. E.g. f:\barcode-arm8-debug.aar.

Once clicked the “Finish” button, the aar file will be packaged into your Android project as a module. Press F4 to open Project Structure, and then add the dependent module:

Источник

Android create aar library

Besides a plain old Java archive file (*.jar), Android Studio can be used to create an Android archive file (*.aar) that can contain classes and methods that make use of Android classes and related files. Like creating the Jar file, an Android project must be created first, then the Android library module can be created and added. The following steps illustrate the process in creating a Android archive file.

Generating the Android archive (*.aar) file

1. Start up Android Studio.
   
2. Select Start a new Android Studio project.

The Create New Project dialog box appears.

Type in an Application name and a Company Domain. Select a Project location. Click Next.

The Target Android Device page appears.

Choose a Minimum SDK, e.g. API 14. Click Next.

The Add an activity to Mobile page appears.

Select Add No Activity. Click Finish.

The Android project is created.

Select File | New | New Module.

The Create New Module dialog box appears.


Select Android library. Click Next.

The Configure your new module page appears.

In the Application/Library name field, type in e.g. MyAarLibrary .

In the Module name field, type in e.g. myaarlibrary .

If necessary, edit the Package name and/or change the Minimum SDK.

Click Next.

The myaarlibrary library is created.

In the newly created myaarlibrary module node, create the classes and methods of the library in the editor, e.g. LibraryClass class with a printLog method.

Note: the example printLog uses the Android.Util.Log class to print a debug log message.

In the Project tree view, select the newly created module node, e.g. myaarlibrary. Then open the Gradle projects pane on the right side. Expand the Tasks node, as shown below.

Double click on assembleRelease.

The Android archive file is generated, e.g. myaarlibrary-release.aar.

1. In Android Studio, create a new project or open up an existing project that you want to use the Android archive file library.
2. In the Project view, expand the libs node of the app.
3. Using the Mac Finder or Windows Explorer, select and copy the Android archive file (*.aar) e.g. myaarlibrary.aar. Paste the aar file into the libs node in Android Studio.

The Copy dialog box appears.


If necessary, change the name. Click OK.

The Aar file is added to the project.

In Android Studio, open the app’s build.gradle file in the editor.

Add in the following line to the dependencies section.

implementation files ( ‘libs/myaarlibrary-release.aar’)

Now the classes and methods in the Android archive file can be used in your app, as shown in the example below.

Источник