[LINUX] Creating an environment that automatically builds with Github Actions (Android)

Overview

We verified CI / CD on Github Actions. Among them, I created a template that can be applied to other development projects on a regular basis. The project of the created template is as follows. github-actions-examples

This time, I will describe it here as a memorandum for building such an environment. Also, the above project has been tried in various other environments, and this time I will focus on the method of automatic build with ʻAndroid application` in Github Actions. I will introduce it to.

Please refer to this article for automatic deployment on the website and basic settings in Github Actions. Creating an environment for automatic deployment with Github Actions (Website)

In addition to this, we are currently verifying the environment construction of automatic build with ʻiOS and ʻUnity. I would like to introduce this as soon as the method is established.

Thing you want to do

• After developing an Android app and pushing it to Github, it will be built at Github Actions.
• The certification key for Release is managed on Github Actions, and the build is performed using the signature key → Release Build
• When the build is complete, [apk file](https://ja.wikipedia.org/wiki/APK_(%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB%E5 % BD% A2% E5% BC% 8F)) and aab file can be downloaded → When installing directly in the terminal Is the [apk file](https://ja.wikipedia.org/wiki/APK_(%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB%E5%BD%A2] % E5% BC% 8F)) Use aab file when delivering to the Google Play Store.
• Build using the key to release to Google Play Store ← Updated at a later date

Build

Conclusion

Please refer to the following contents respectively

• Github Actions config file for Debug Build: [android-debug-build.yml](https://github.com/TakuKobayashi/github- actions-examples / blob / master / .github / workflows / android-debug-build.yml)
• Github Actions configuration file for Release Build: [android-release-build.yml](https://github.com/TakuKobayashi/github- actions-examples / blob / master / .github / workflows / android-release-build.yml)
• app/build.gradle

Various explanations

JDK setup

Build an Android application as a Java application. This time I will build using JDK to build (even if I am developing with Kotlin) In Github Actions, use action / setup-java to set up JDK. I can. Also, this time we will build with Java version 1.8, so specify the version to use. Describe as follows in the yml file.

jobs:
  build:
    steps:
      ...
      - name: setup JDK 1.8
        uses: actions/setup-java@v1
        with:
          java-version: 1.8

Android SDK setup

Once you have set up the JDK, the next step is to download and set up the ʻAndroid SDK. ʻAndroid SDK is generally downloaded by Android Studio, but this time it is executed by CLI, so download it by a method that does not use Android Studio. Download the zip file that contains the ʻAndroid SDK in the Command line tools onlysection of [Android Studio](https://developer.android.com/studio). Thiszip file depends on the version of ʻAndroid SDK Tools. Enter the URL that specifies the version you want to download and use. The following process is the process of downloading and unzipping the zip file.

wget --quiet --output-document=android-sdk.zip https://dl.google.com/android/repository/sdk-tools-linux-${{ matrix.sdk-tools }}.zip
unzip -d android-sdk-linux android-sdk.zip

For matrix.sdk-tools, specify the value of the version of ʻAndroid SDKabove. In this example, we will use4333796`.

ʻWhen the Android SDK is downloaded and decompressed, pass the settings and environment variables PATHfor usingbuild-tools`` platform-tools`.

echo y | android-sdk-linux/tools/bin/sdkmanager "platforms;android-${{ matrix.compile-sdk }}" >/dev/null
echo y | android-sdk-linux/tools/bin/sdkmanager "platform-tools" >/dev/null
echo y | android-sdk-linux/tools/bin/sdkmanager "build-tools;${{ matrix.build-tools }}" >/dev/null
export ANDROID_HOME=$PWD/android-sdk-linux
export PATH=$PATH:$PWD/android-sdk-linux/platform-tools/

Then accept lincense to use ʻAndroid SDK`.

set +o pipefail
yes | android-sdk-linux/tools/bin/sdkmanager --licenses
set -o pipefail

Now that you have set up the ʻAndroid SDK`, you can build your Android app.

gradle setup

Use Gradle to build the app on Android. The Gradle settings are set up automatically by running gradlew. (Various Gradle commands are also executed using gradlew), updating permissions so that the gradlew file can be executed.

chmod +x ./gradlew

(Bonus) Warning resolved

It is set to build up to the above, but if you build as it is, Warning will appear, so create the following file to prevent Warning.

sudo touch /root/.android/repositories.cfg

Debug Build

When the environment for building the Android application is ready, first perform Debug Build. Debug Build can be built by executing the following command.

./gradlew assembleDebug

A signature is required to build an Android app, but in Debug Build which does not specify a signature key, it is generated in ~ / .android / debug.keystore when ʻAndroid SDKis installed. The build will be done using thedebug keystore`.

【reference】 I checked the keystore for debug

Release Build

In the case of Debug Build, the build was done using Android's debug keystore, but when distributing the built Android application to Google Play Store etc., it is distributed by the application built with the default signing key. can not do. In order to distribute, you can build the application to be distributed to the Store by creating the signature key yourself and building with the created signature key (here, such a build is called Release Build". Masu) In the following, I will show you how to do Release Build on Github Actions. For creating the key, refer to here.

Make it possible to refer to the key used for the build

In order to build by specifying the created signature key, it is applied when building by specifying the signature key file in ʻapp / bulk.gradle`.

At this time, the information of storeFile`` storePassword keyAlias`` keyPassword is required, so specify this information in ʻapp / buld.gradle. However, since this information is an environment variable that you want to keep secret and manage, describe the above information in local.properties that describes the environment variable on Android, and put the contents in ʻapp / build.gradle. It will be referenced when building by loading it. (local.properties is listed in .gitignore by default)

The description in ʻapp / buld.gradle` is as follows.

build.gradle

Properties properties = new Properties()
def localPropertiesFile = project.rootProject.file('local.properties');
if(!localPropertiesFile.exists()){
    //If there is no localPropertiesFile, create it
    localPropertiesFile.createNewFile();
}
properties.load(localPropertiesFile.newDataInputStream())

In the above example, if local.properties does not exist at build time, create a new one, and if there is, load the existing file to apply it to the settings. (If you do not do this, you will get a build error if local.properties does not exist (for example, when you do Debug Build))

To apply the read value of local.properties to the build when Release Build, write as follows.

build.gradle

android {
    ...
    signingConfigs {
        release {
            //Describe only when the specified file exists
            if(!properties.getProperty("RELEASE_STORE_FILE", "").empty){
                storeFile file(properties.getProperty("RELEASE_STORE_FILE", ""))
            }
            storePassword properties.getProperty("RELEASE_STORE_PASSWORD", "")
            keyAlias properties.getProperty("RELEASE_KEY_ALIAS", "")
            keyPassword properties.getProperty("RELEASE_KEY_PASSWORD", "")
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

At this time, set the following environment variables in local.properties.

local.properties

RELEASE_STORE_FILE=File path of signing key file(Absolute path)String
RELEASE_STORE_PASSWORD=Store password string
RELEASE_KEY_ALIAS=Key alias string
RELEASE_KEY_PASSWORD=Key password string

• When the above settings are applied, if you want to perform Release Build locally, describe the above contents in local.properties and describe the information of the signing key file.

Key management

Normally, the signing key file is a binary file, so you need to save it somewhere and get it or embed it in your project. However, there is a problem that the signing key file is known to many developers.

So this time, save the signature key management in Github Secrets and apply it as a secret environment variable </ font>

base64 Android build signing key.keystore

echo ${ANDROID_REALSE_BASE64_KEY} | base64 -d > ./release-application-key

RELEASE_STORE_FILE=File path of signing key file(Absolute path)String
RELEASE_STORE_PASSWORD=Store password string
RELEASE_KEY_ALIAS=Key alias string
RELEASE_KEY_PASSWORD=Key password string

echo ${ANDROID_REALSE_BASE64_KEY} | base64 -d > ./release-application-key
echo "RELEASE_STORE_FILE=`pwd`/release-application-key" >> ./local.properties
echo "RELEASE_STORE_PASSWORD=${ANDROID_REALSE_KEY_PASSWORD}" >> ./local.properties
echo "RELEASE_KEY_ALIAS=key0" >> ./local.properties
echo "RELEASE_KEY_PASSWORD=${ANDROID_REALSE_KEY_PASSWORD}" >> ./local.properties

./gradlew assembleRelease

./gradlew bundleRelease

- uses: actions/upload-artifact@master
  with:
    name: outputs
    path: app/build/outputs/