On this article, we’ll discuss multi-library tasks in Android. It isn’t one thing extraordinary, however not one thing out of the extraordinary both.
You will have come throughout multi-library tasks in your line of labor, or you might be trying into changing your library into sub-modules for higher construction and group. Irrespective of the case, try to be effectively conscious of what lies in entrance of you earlier than diving in.
Writing your personal library in Android is neat. You get an opportunity to jot down some code that may assist different builders (and even your self).
Since libraries can’t be a standalone challenge by themselves, they’re often all the time paired in a challenge with an software. This permits creating the library to be a easy course of the place you add a function/repair a bug after which you may take a look at it instantly with the applying you’ve within the challenge. Thus, simulating (in an area means) how a developer will combine your library.
However, what in case your library depends on one other library you’re creating?
In case you are not conscious of it, it’s best to know {that a} library (learn aar) can’t include one other native library inside it. It might depend on libraries remotely (through dependencies), however not on one thing native.
This isn’t supported in Android, and whereas some options popped up in the course of the years (FatAar), these didn’t all the time clear up the issue and are usually not updated. There’s even a Google Issue Tracker requesting this function that has been open for fairly a while and is receiving loads of consideration from the neighborhood. However let’s determine which partitions we are able to break and which we can’t.
Think about your challenge hierarchy appears like this:
-- App
|
-- OuterLib
|
--- InnerLib
So, since InnerLib can’t be a part of your unique challenge, the place can it reside? And likewise how would you have the ability to work domestically whereas creating options inside InnerLib?
We’re going to reply these questions on this article.
Git Submodule
For many technical issues, there isn’t all the time only one answer. Often, there are extra, however every answer has its drawbacks. It is all a query of which drawbacks you’re extra comfy dwelling with on the finish of the day.
To reply our first query, the place can InnerLib reside, now we have a number of choices:
- Make InnerLib a submodule of our unique challenge
- Make InnerLib a distant dependency of its personal
In case you are not conscious of submodules in Git, Git’s documentation is an effective place to familiarize your self with them. Quoting from it (the primary paragraph):
It typically occurs that whereas engaged on one challenge, you might want to use one other challenge from inside it.
Maybe it’s a library {that a} third social gathering developed or that you simply’re creating individually and utilizing in a number of father or mother tasks.
A standard difficulty arises in these situations: you need to have the ability to deal with the 2 tasks as separate but nonetheless have the ability to use one from throughout the different.
This paragraph reveals us that that is precisely our use case. Utilizing a submodule has its advantages. All of your code is in a single place, is simple to handle, and is simple to develop domestically.
However submodules have some weaknesses. One is the truth that you have to all the time pay attention to which department your submodule is pointing to. Think about a situation the place you’re on a launch department in your primary repository and your sub-module is on a function department. When you don’t discover, you launch a model of your code with one thing that isn’t prepared for manufacturing. Whoops.
Now take into consideration this inside a staff of builders. One careless mistake could be expensive.
If the primary possibility sounds problematic for you, then internet hosting your library in one other repository is your second alternative. Establishing the repository is fairly easy, however how do you’re employed domestically now?
Working Regionally
Now that we have gotten our challenge arrange correctly, we are going to most likely have a line just like this in our OuterLib construct.gradle file:
dependencies {
implementation 'url_to_remote_inner_lib_repository'
}
How can we make the event cycle environment friendly and simple to work with? If we develop some function in InnerLib, how can we take a look at issues out in OuterLib? Or in our software?
One answer which may come up is to import our InnerLib domestically to our OuterLib challenge, whereas having InnerLib .gitignored in our OuterLib challenge. You are able to do so simply by proper clicking on the title of the challenge within the left hand facet menu in Android Studio and going to New → Module.
Learn how to import a module (Step 1)
Then within the window that opens up, you may select the Import possibility on the backside left:
Learn how to import a module (Step 2)
That sounds simple and easy up to now, however what’s the catch?
Every time you modify a file that belongs to InnerLib, the adjustments received’t be mirrored inside InnerLib since it’s ignored. So, every change you wish to make has to occur inside InnerLib after which it’s important to import it once more inside OuterLib to see the adjustments.
This doesn’t appear proper. There should be a greater means of doing this.
With only a few strains in our settings.gradle file, we are able to make certain our information keep in sync once we make adjustments in InnerLib.
After we imported InnerLib into our challenge, Android Studio made a duplicate of InnerLib and cached it. That’s the reason we wanted to re-import the library for each change we made inside it. We are able to inform Android Studio the place to reference the information from utilizing the projectDir attribute.
Our settings.gradle may look one thing like this:
embrace ':outerLib', ':innerLib', ':app'
To reference our InnerLib domestically, we must change settings.gradle into this:
embrace ':outerLib', ':innerLib', ':app'
challenge('innerLib').projectDir = new File('PATH_TO_INNER_LIB')
Utilizing this method, our InnerLib information will probably be linked to our working listing, so each change we make will probably be mirrored instantly.
However, we want flexibility when working domestically on OuterLib with a distant model of InnerLib. What we wrote above contained in the settings.gradle file will solely enable us to work domestically and absolutely we don’t wish to commit that as it’s.
Maven Native
If the method above doesn’t sit fairly proper with you, there’s a totally different one you may take. Similar to you’d publish your library publicly with maven, you are able to do the identical factor domestically with maven native. Maven native is a set of repositories that sit domestically in your machine.
Beneath are the paths for mavenLocal relying on the working system of your machine:
- Mac → /Customers/YOUR_USERNAME/.m2
- Linux → /dwelling/YOUR_USERNAME/.m2
- Home windows → C:UsersYOUR_USERNAME.m2
In essence you may publish your library domestically after which hyperlink to it in your challenge. Doing it this fashion, we are able to hyperlink our challenge to InnerLib.
As a way to enable this configuration in our challenge, we have to do the next issues:
- Add mavenLocal() as a repository inside our repositories clause. That is to permit our challenge the flexibility to seek for repositories domestically
buildscript {
repositories {
mavenLocal()
}
}
...
allprojects {
repositories {
mavenLocal()
}
}
-
Change our implementation line inside our dependencies clause to reference our InnerLib as if it we’re referencing it remotely
-
To publish InnerLib domestically, we are going to create a file known as publishingLocally.gradle that may include the next:
apply plugin: 'maven-publish'
challenge.afterEvaluate {
publishing {
publications {
library(MavenPublication) {
setGroupId groupId
setArtifactId artifactId
model versionName
artifact bundleDebugAar
pom.withXml {
def dependenciesNode = asNode().appendNode('dependencies')
def dependencyNode = dependenciesNode.appendNode('dependency')
dependencyNode.appendNode('groupId', 'your_group_id')
dependencyNode.appendNode('artifactId', 'your_artificat_id')
dependencyNode.appendNode('model', 'your_version')
}
}
}
}
}
- Inside your software degree construct.gradle file, add the road:
apply from: '/.publishingLocally.gradle
If this feature appears a bit too good to be true, it’s. Whereas on one hand, we are able to develop issues domestically seamlessly simply as if we had been working with a distant library. On the opposite, if we make any change inside InnerLib whereas working domestically, it’s required to publish it domestically once more. Whereas this isn’t a expensive process, it does create a must carry out tedious duties again and again.
A Answer for Working Regionally and Remotely
We wish to keep away from the fixed must re-publish our InnerLib package deal every time we make a change domestically. We have to work out a technique to make our challenge pay attention to these adjustments.
Within the Working Regionally part, we discovered how to try this, however we had a problem with committing the settings.gradle file. To unravel this downside so we are able to work each domestically and remotely with our InnerLib, we are going to use a parameter we are going to outline in our gradle.properties file.
The gradle.properties file is a spot the place you may retailer challenge degree settings that configure your growth atmosphere. This helps guarantee that all of the builders on a staff have a constant growth atmosphere.
Some settings you could be conversant in which are discovered inside this file are AndroidX help (android.useAndroidX=true) or the JVM arguments (org.gradle.jvmargs=-Xmx1536m).
To assist us clear up our state of affairs, we are able to add a parameter right here to point whether or not we wish to work domestically or not. One thing alongside the strains of:
workingLocally = false
This parameter will grant us the flexibility to tell apart between which settings we’re working with, both domestically or with manufacturing code. First, let’s alter what now we have in our settings.gradle file by wrapping it in a situation that checks if our parameter is true:
embrace ':outerLib', ':innerLib', ':app'
if (workingLocally.booleanValue()) {
challenge('innerLib').projectDir = new File('PATH_TO_INNER_LIB')
}
This fashion, we point out to the challenge to get the information for our InnerLib domestically from our machine.
One other place the place we have to change our logic is in our construct.gradle file. Right here, as a substitute of getting the code to our library remotely in our dependencies block, we are able to point out whether or not we’re relying on it domestically or not.
dependencies {
if (workingLocally.booleanValue()) {
implementation 'innerLib'
} else {
implementation 'url_to_remote_repository'
}
}
Phrase of warning: You need to by no means commit the gradle.properties file when working domestically.
The journey was lengthy and will have appeared fairly exhausting. However now now we have a full-proof setup for working domestically and remotely on a a number of library challenge.
When you encounter any points or want to give your tackle this, be at liberty to depart a remark.
