CI/CD with GitHub Actions in Android Kotlin

Introduction

CI/CD with GitHub Actions helps you automatically build, test, and deliver your Android app. It saves time and reduces mistakes by doing these steps for you.

You want to test your Android app every time you change the code.

You want to build your app automatically before sharing it.

You want to send your app to testers or app stores without doing it manually.

You want to catch errors early by running tests on every update.

You want to keep your app delivery fast and reliable.

Syntax

Android Kotlin

name: Android CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        distribution: 'temurin'
        java-version: '17'
    - name: Build with Gradle
      run: ./gradlew build
    - name: Run tests
      run: ./gradlew test

The on section tells when the workflow runs, like on code changes.

The jobs section defines steps like building and testing your app.

Examples

This runs the workflow only when you push code to the main branch.

Android Kotlin

on:
  push:
    branches: [ main ]

This job runs on a Linux machine and checks out your code.

Android Kotlin

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

This step builds the debug version of your Android app.

Android Kotlin

- name: Build with Gradle
  run: ./gradlew assembleDebug

This step runs your app's unit tests to check for errors.

Android Kotlin

- name: Run unit tests
  run: ./gradlew test

Sample App

This GitHub Actions workflow runs when you push code to the main branch. It checks out your code, sets up Java 17, builds your Android app using Gradle, and runs tests.

Android Kotlin

name: Android CI/CD

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        distribution: 'temurin'
        java-version: '17'
    - name: Build with Gradle
      run: ./gradlew build
    - name: Run tests
      run: ./gradlew test

Important Notes

Make sure your Android project has a working gradlew script in the root folder.

You can add more steps to upload build files or notify your team.

Use the runs-on setting to choose the operating system for your build.

Summary

GitHub Actions automates building and testing your Android app.

Workflows run on code changes to keep your app healthy.

Simple YAML files define what steps to run and when.

Practice

1. What is the main purpose of using GitHub Actions in an Android Kotlin project?

easy

A. To automate building and testing the app on code changes

B. To write Kotlin code faster

C. To manually deploy the app to users

D. To edit the AndroidManifest.xml file

Solution

1. Step 1: Understand GitHub Actions role

   GitHub Actions automates tasks like building and testing when code changes.

2. Step 2: Identify the main benefit

   This automation helps keep the app healthy without manual work.

3. Final Answer:

   To automate building and testing the app on code changes -> Option A

4. Quick Check:

   Automation = building and testing [OK]

Hint: GitHub Actions automates tasks on code changes [OK]

Common Mistakes:

• Thinking it writes code automatically
• Confusing manual deployment with automation
• Assuming it edits app files directly

2. Which of the following is the correct way to specify a job that runs on Ubuntu in a GitHub Actions workflow YAML file?

easy

A. runs-on: ubuntu-latest

B. runs: ubuntu-latest

C. run-on: ubuntu-latest

D. runs_on: ubuntu-latest

Solution

1. Step 1: Recall GitHub Actions syntax for runner

   The correct key is runs-on with a hyphen.

2. Step 2: Match the correct option

   runs-on: ubuntu-latest uses runs-on: ubuntu-latest, which is valid syntax.

3. Final Answer:

   runs-on: ubuntu-latest -> Option A

4. Quick Check:

   Key is runs-on with hyphen [OK]

Hint: Remember: 'runs-on' uses a hyphen, not underscore or other [OK]

Common Mistakes:

• Using underscore instead of hyphen
• Using 'runs' or 'run-on' keys incorrectly
• Confusing key names with similar words

3. Given this GitHub Actions step in a workflow:

steps:
  - name: Build Debug APK
    run: ./gradlew assembleDebug

What will this step do when the workflow runs?

medium

A. It deploys the app to the Google Play Store

B. It runs unit tests only

C. It cleans the project without building

D. It runs the Gradle command to build the debug version of the app

Solution

1. Step 1: Understand the Gradle command

   ./gradlew assembleDebug builds the debug APK of the app.

2. Step 2: Identify the step action

   The step runs this command, so it builds the debug version.

3. Final Answer:

   It runs the Gradle command to build the debug version of the app -> Option D

4. Quick Check:

   assembleDebug = build debug APK [OK]

Hint: assembleDebug builds debug APK, not tests or deploys [OK]

Common Mistakes:

• Confusing assembleDebug with deploy commands
• Thinking it runs tests only
• Assuming it cleans the project

4. You wrote this GitHub Actions workflow snippet:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Build APK
        run: gradlew assembleDebug

Why might this workflow fail during the build step?

medium

A. Because 'actions/checkout@v2' is an invalid action

B. Because the command should be './gradlew assembleDebug' with './' prefix

C. Because 'runs-on' should be 'runs_on'

D. Because the job name 'build' is not allowed

Solution

1. Step 1: Check the build command syntax

   The Gradle wrapper command needs './gradlew' to run the local script.

2. Step 2: Identify the error cause

   Missing './' causes 'gradlew' not found error, failing the build step.

3. Final Answer:

   Because the command should be './gradlew assembleDebug' with './' prefix -> Option B

4. Quick Check:

   Use './gradlew' to run Gradle wrapper [OK]

Hint: Always prefix Gradle wrapper with './' in Linux runners [OK]

Common Mistakes:

• Omitting './' before gradlew
• Thinking action version is invalid
• Misnaming 'runs-on' key
• Assuming job names are restricted

5. You want your GitHub Actions workflow to run tests only when Kotlin source files change. Which trigger configuration correctly achieves this?

hard

A. on:
schedule:
- cron: '0 0 * * *'

B. on:
push:
branches:
- main

C. on:
push:
paths:
- '**/*.kt'

D. on:
pull_request:
paths-ignore:
- '**/*.kt'

Solution

1. Step 1: Understand GitHub Actions triggers

   The paths filter runs workflow only if matching files change.

2. Step 2: Match trigger to Kotlin files

   on: push: paths: - '**/*.kt' triggers on push when any .kt file changes, which is correct.

3. Final Answer:

   on: push: paths: - '**/*.kt' -> Option C

4. Quick Check:

   Use 'paths' to trigger on specific file changes [OK]

Hint: Use 'paths' filter to run workflow on specific file changes [OK]

Common Mistakes:

• Using 'paths-ignore' instead of 'paths'
• Triggering on branch only, not file changes
• Using schedule trigger for file changes