No Version? No Problem! .. Jitpack comes to the rescue

I will try to follow a rule now (hopefully). If I give out an advice more than 2–3 times and it proves to be helpful then I will try to write about it.

Have you ever been caught up in a scenario that the library you are using heavily in your app has a critical bug which has already been resolved (for example: in a pull request) but a version release for that particular library hasn’t been scheduled in the near future?

Or maybe you fixed the issue yourself by submitting a patch and now you want to use it in your app but it could take quite long until it is merged into the repository and released.

Or you may want to use an API merged into the codebase which is not yet available in the latest release.

What do we do in such cases? I will list possible solutions that I know of :

Option A : Import as a library module

One option is to import the source code as a library module for our project. However, I would not recommend doing so since it will be hard to maintain. There’s no easy way to get any future changes or commits from the library. If in future we do plan to fetch the latest code, all our previous changes are gone.

Option B : Fork and add as an aar

We fork the repository and make changes if required. Then, we create an aar from our fork and add the aar of library in our libs folder. This option also works and is much better than option A but :

• We might still need to fetch the transitive dependencies by setting transitive = true.
• We still can not maintain it easily. Each time we want to fetch more commits, we will need to generate another aar file and add it again manually. Why do this when we have a better option?

If you know of any other options, we can put them here in the list between B and I. For J.

Option J: Jitpack!

Many good things and great names start with J.

If you want to know how Jitpack works there are many resources available. One of the resources is here which tells us how we can publish an android library via jitpack easily. We need not worry about that right now.

In our case, most of the work is already done as almost all the libraries already have their repositories setup as a maven dependency. All we we need to do is :

• Fork a library, make some non-ugly changes to it (*cough* hotfix *cough*).
• Create a release / feature-snapshot branch and we are almost done! (In most cases).
• Go to jitpack.io and sign in with the github account.
• Look up our forked library by typing it’s name in the format https://github.com/User/Repo or browse through the list of repositories on the left and select the one intended.
• Head over to Releases / Branches section as shown below and we will find our newly created release or our feature-snapshot branch version listed here.

• And we are ready to use it in our project!! Once we click the “Get it” button above, Jitpack tells us how to use it in our projects :

Yes! That’s it!

You can find extensive documentation about Jitpack here.

Important Note: Please read the license of the original repository carefully before following this article.

I am not sure if this post counts as an android advice or badvice but it has helped me and my colleagues a number of times and jitpack is the go-to method that we rely upon in such cases. If you have any alternative strategies that you recommend, please do respond with it, I’m all ears!

Special thanks to Raveesh Bhalla, Adit Lal, Ritesh Gupta, Saket Narayan and Vikas Kashyap for reviewing.