DevOps-ify Android libraries with GitHub Actions and Package Registry🚀

Hello Android developers, in this article we’ll take a look at publishing Android library to the GitHub Package Registry and automating it with GitHub Actions CI. You might have developed a cool Android library and wanted to publish it somewhere. In some situations, the GitHub Package Registry is really a good choice. Let’s discuss more on it.

What is GitHub Package Registry? 🤷‍♀️

With GPR, you can safely publish and consume packages. It supports various types of packages for Maven, NPM, Docker, NuGet, RubyGems, etc.

What’s different in GitHub Package Registry? 🤷‍♀️

In the Android library context, comparing it with Bintray / JCenter / MavenCentral, GPR provides security for consuming package. Anybody directly can’t use the package without an access token.
If you want to develop a private Android library only for some authenticated developers. For e.g. You have to develop an Android library only for a specific organisation. Only that organisation will be able to use this library. Comparing this with Bintray, then it’s PAID 💰 for private packages. That’s how GPR is the right choice in some cases.

That’s a short introduction about GPR 😃.

Getting started 🚀

You can refer to this repository which includes the code which we’re going to use in this example.

In this example, we’ll set up a GitHub Actions workflow which will be triggered whenever a git tag is pushed on GitHub and it’ll publish Android library to GPR and will also create GitHub release automatically.

So you just need to code, push and chill 😍. So let’s start.

Configure Library module

Considering you already have developed your library we’ll directly start with configuring setup for publishing it to GPR.

Open build.gradle file of your library module.
Apply maven-publish plugin at the top of the file:

apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'maven-publish'

Declare Android library details such as group, artifact, version, name, etc as below 👇:

ext {
    mGroupId = "com.example"
    mArtifactId = "simple-library"
    mVersionCode = 1
    mVersionName = "0.2.0"

    mLibraryName = "SimpleLibrary"
    mLibraryDescription = "Simple Library for simple things!"
}

Create a task for generating Android source (.jar):

task androidSourcesJar(type: Jar) {
    archiveClassifier.set('sources')
    from android.sourceSets.main.java.srcDirs
}

Configure maven publication options as below 👇. This will be responsible for a group and an artifact ID of your Android library.

afterEvaluate {
    publishing {
        publications {
            maven(MavenPublication) {
                groupId mGroupId
                artifactId mArtifactId
                version mVersionName

                from components.release

                artifact androidSourcesJar

                pom {
                    name = mLibraryName
                    description = mLibraryDescription
                }
            }
        }
        repositories {}
    }
}

In repositories, add details of your package. In this configuration, keep the name as "GitHubPackages" and URL should be in the format "https://maven.pkg.github.com/USER/REPO".
Here we’ll get credentials from environment variables.
Here password will be a GitHub’s PERSONAL ACCESS TOKEN which should have a permission write:package.

repositories {
    maven {
        name = "GitHubPackages"
        url = uri("https://maven.pkg.github.com/PatilShreyas/AndroidGPR")
        credentials {
            username = System.getenv("GPR_USER")
            password = System.getenv("GPR_KEY")
        }
    }
}

Thus, Gradle task — publish will be generated. But package artifact should be generated before publishing package. So we’ll define it as below 👇.

Note: Whenever gradlew publish is executed then assembling will be performed first.

publish.dependsOn assemble

Setup Workflow

We’ll create a workflow which will be triggered whenever a git tag is pushed. So let’s create.

Create a file release.yml in /.github/workflows directory. Initialize it as below:

name: Release
on:
  push:
    tags:
      - "v*"

Add basic setup for job as below 👇. Here Gradle caching is optional.

jobs:
  publish:
    name: Release Simple Library
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v1

      - name: Set up JDK 12
        uses: actions/setup-java@v1
        with:
          java-version: 12

      - name: Cache Gradle and wrapper
        uses: actions/cache@v2
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-gradle-

      - name: Grant Permission for Gradlew to Execute
        run: chmod +x gradlew

Now, let’s build .aar (Android Library artifact):

- name: Build AAR ⚙️🛠
  run: bash ./gradlew :simplelibrary:assemble

Now if the above build is successful then we can proceed to publish the package to GPR. Use secrets.GITHUB_TOKEN which is exposed by GitHub Actions CI already.

- name: Publish to GitHub Package Registry 🚀
  run: bash ./gradlew :simplelibrary:publish
  env:
    GPR_USER: ${{ github.actor }}
    GPR_KEY: ${{ secrets.GITHUB_TOKEN }}

Note: If you remember, we were reading username and password from System Environment variables in build.gradle configuration of the library. We’ll need to expose them from here.

Now once the package is published to GPR we’re ready to create a GitHub release. (Here we are keeping draft as true so that we can release it later).

- name: Create Release ✅
  id: create_release
  uses: actions/create-release@v1
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  with:
    tag_name: ${{ github.ref }}
    release_name: ${{ github.ref }}
    draft: true
    prerelease: false

Once the GitHub release is created it will upload library artifact to the release:

- name: Upload Simple Library AAR 🗳
  uses: actions/upload-release-asset@v1
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  with:
    upload_url: ${{ steps.create_release.outputs.upload_url }}
    asset_path: simplelibrary/build/outputs/aar/simplelibrary-release.aar
    asset_name: simple-library.aar
    asset_content_type: application/aar

Yeah, that’s it! 😃 Now let’s test it 🧪.

Test Workflow

Follow these steps for testing workflow:

Go to VCS → Git → Tag.

Create a tag using valid version.

Now push that newly created tag.

Once it’s pushed navigate to your repository’s Actions tab.

Once you see success status of CI as seen in the above image means everything worked perfectly 😍.

Now navigate to the Packages section of repository and you’ll see package details there.

Now let’s verify if GitHub release is created or not. Navigate to releases section of the repository and see.

As you can see draft release is created here. Now you can edit it, add a description of the release and then you can publish this release.

Yeah! Now anybody can use this package if they have an access token. But how to use it? 🤔 Let’s see.

Creating an Access token for reading package

As we discussed, we’ll need GitHub access token for consuming package. So let’s create an access token for it.

Navigate to https://github.com/settings/tokens and then click Generate New Token.
Make sure to check scope — read:packages.

This means only the reading package is possible using this token. So it’s safe to give it to the consumer.

Click “Generate Token” and the token will be generated. Make sure you’ve noted token.

Now it’s time to use Android library in app.

Configuring Android app

Open Android app project from which the library will be used and perform the following steps.

Just open build.gradle of the app module.
Add repository for GitHub package. In the credentials, keep your GitHub’s username as username and put the token which we created in the previous step as a password.

repositories {
    maven {
        name = "GitHubPackages"
        url = uri("https://maven.pkg.github.com/PatilShreyas/AndroidGPR")
        credentials {
            username = 'GITHUB_USERNAME_HERE'
            password = 'ACCESS_TOKEN_HERE'
        }
    }
}

Finally, add a dependency of the Android library:

dependencies {
    // Simple library
    implementation 'com.example:simple-library:0.2.0'
}

Yeah, that’s it. Now just do Gradle sync and enjoy 🎉.

Isn’t it easy 😃? This is how you can automate or DevOps-ify your Android library workflow so you will just write code, push it, chill and enjoy 😅.

I hope you liked this article and it’ll be helpful for everyone!

Thank you! 😄