Why CI/CD with GitHub Actions in Android Kotlin? - Purpose & Use Cases

The Big Idea

What if your app could build and test itself every time you save your code?

The Scenario

Imagine you finish writing your Android app code and want to test it on different devices and then upload it to the app store. You have to do each step by hand: run tests on your computer, build the app, check for errors, and then manually upload the app. This takes a lot of time and you might forget a step.

The Problem

Doing all these steps manually is slow and tiring. You might miss running some tests or upload a broken app by mistake. It's easy to make errors, and fixing them later wastes even more time. Plus, every time you change your code, you have to repeat all these steps again.

The Solution

CI/CD with GitHub Actions automates these steps for you. Every time you save your code, it automatically runs tests, builds your app, and can even upload it. This means fewer mistakes, faster updates, and more time to focus on making your app better.

Before vs After

✗ Before

Run tests manually
Build APK manually
Upload APK manually

✓ After

on: push
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Build and test
        run: ./gradlew build test
      - name: Upload APK
        run: ./upload-script.sh

What It Enables

It lets you deliver app updates quickly and reliably without worrying about missing steps or breaking your app.

Real Life Example

A developer pushes code to GitHub and instantly sees tests run and the app build. If all is good, the new version is ready for testers or even automatically sent to the app store.

Key Takeaways

Manual app building and testing is slow and error-prone.

GitHub Actions automates testing, building, and deployment.

This saves time and reduces mistakes, speeding up app delivery.

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