Revamp Your Android App Workflow with GitHub Actions: Automate Build and Distribution in Style!

Photo by Alex Knight on Unsplash

Do you feel that building and distributing applications manually is too complicated, impractical, and repetitive?

Why use automation?

In the process of developing an application, many stages must be passed through. Based on the development lifecycle, there are at least several stages that must be followed, including

• planning
• analysis
• design
• implementation
• testing
• deployment
• maintenance.

Of course, by following all of these stages, the development process can take a significant amount of time. However, what if you could streamline specific aspects of the process so that you could focus on other stages instead? so this is why you need automation

By automating the build and distribution process using tools like GitHub Actions, you can significantly reduce the time and effort required to deploy or test the app. Instead of manually building and distributing the app every time you make changes to the code, you can set up a series of automated workflows that will handle these tasks for you.

One of the most significant benefits of automation is the ability to reduce errors and increase consistency. Automating the process eliminates the potential for human error and ensures that every build and distribution is done the same way, with the same settings and configurations. This can result in more reliable and higher-quality applications.

Step to automate deploy the app

1 . Setting up a GitHub Actions workflow

• Create a new YAML file in the repository’s .github/workflows directory. You can name the file whatever you like, but it should have a .yml extension.

android.yml file

2 . Building the Android app

• To build an Android app, you need to set up the build.gradle file to generate the app. also need to set the certificate or Keystore
• In GitHub Actions, you can automate this process with various triggering options. For example, you can trigger the build process when creating a pull request or by manually clicking a button.

name: Android CI

env:
  main_project_module: app

on:
  push:
    branches: [ "master" ]
  pull_request:
    branches: [ "master" ]

• Need to setup the operating system as well and java jdk

steps:
    - uses: actions/checkout@v3
    - name: set up JDK 11
      uses: actions/setup-java@v3
      with:
        java-version: '11'
        distribution: 'temurin'
        cache: gradle

• Then, you can include the Gradle build command in your GitHub Actions workflow file, similar to the example image shown below

   
    - name: Grant execute permission for gradlew
      run: chmod +x gradlew
    - name: Build with Gradle
      run: ./gradlew build


    - name: Build debug app
      run: ./gradlew assembleDebug
    - name: Check directory
      run: ls

this is how the build process runs on the GitHub actions workflow at the actions tab in GitHub

• For further improvement, you can also cache the Gradle dependencies in GitHub Actions to speed up the build process and reduce the usage of resources. This can be achieved by adding a cache action in your workflow file to save the dependencies between builds so that they don’t need to be downloaded again for each build. This can significantly reduce the build time and make the process more efficient

3 . Uploading the Android app

• After the building process, you can upload the app into the artifact with this command

- name: Upload artifacts
      uses: actions/upload-artifact@v3
      with:
          name: pokedex 
          path: ${{ env.main_project_module }}/build/outputs/apk/debug/app-debug.apk

• After building and uploading the artifact, you can view it in the GitHub Actions workflow logs and download it as a zip file. The artifact may contain various files, such as the APK, mapping file, or other build artifacts, depending on your build process and configuration. You can then use the artifact for testing, distribution, or other purposes as needed.

• This is just a simple example of what can be achieved with GitHub Actions. There are many other possibilities and actions that you can perform, such as uploading your app to Firebase App Distribution or Google Play Store. You can also send notifications to Slack or other platforms, or perform other custom actions based on your requirements. The flexibility and power of GitHub Actions make it a versatile tool for automating your Android app build and deployment process.

Conclusion

In conclusion, automating the Android app build process using GitHub Actions is a highly efficient and effective approach that provides numerous benefits, such as time-saving, error reduction, consistency, flexibility, and integration with other tools and services.

By automating the process, developers can focus on more important tasks, leading to higher-quality apps and a more streamlined development process. With its powerful and versatile capabilities, GitHub Actions is a valuable tool for any Android app developer looking to improve their workflow and achieve greater success in their projects.

Automate your Android app build process with GitHub Actions to save time, reduce errors, and boost efficiency. Try it out and experience the benefits firsthand!

Explore more Github actions here

https://github.com/features/actions

wanna see my dummy project containing GitHub actions here

https://github.com/adityaputra11/Pokedex