Créer un environnement qui se construit automatiquement avec Github Actions (version Android)

Aperçu

Nous avons vérifié CI / CD dans Actions Github. Parmi eux, j'ai créé un modèle qui peut être appliqué régulièrement à d'autres projets de développement. Le projet du modèle créé est le suivant. github-actions-examples

Cette fois, je le décrirai ici comme un mémorandum pour la construction d'un tel environnement. De plus, le projet ci-dessus a été essayé dans divers autres environnements, et cette fois nous allons nous concentrer sur la méthode de construction automatique avec ʻAndroid application` dans Github Actions. Je vais le présenter.

Veuillez consulter cet article pour le déploiement automatique sur le site Web et les paramètres de base dans les actions Github. Création d'un environnement de déploiement automatique avec des actions Github (site Web)

En plus de cela, nous vérifions actuellement la construction de l'environnement de la construction automatique avec ʻiOS et ʻUnity. Je voudrais vous présenter ceci dès que la méthode sera établie.

Chose que tu veux faire

• Après avoir développé une application Android et l'avoir poussée sur Github, elle sera créée sur Actions Github.
• La clé de certification pour Release est gérée sur Actions Github, et la construction est effectuée à l'aide de la clé de signature → Release Build
• Lorsque la compilation est terminée, [fichier apk](https://ja.wikipedia.org/wiki/APK_(%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB%E5 % BD% A2% E5% BC% 8F)) et fichier aab peuvent être téléchargés → Lors de l'installation directement dans le terminal Est [fichier apk](https://ja.wikipedia.org/wiki/APK_(%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB%E5%BD%A2] % E5% BC% 8F)) Utilisez fichier aab lors de la livraison sur le Google Play Store.
• Construire en utilisant la clé pour libérer sur Google Play Store ← Mis à jour à une date ultérieure

Build

Conclusion

Veuillez vous référer respectivement au contenu suivant

• Github Actions fichier de configuration pour Debug Build: [android-debug-build.yml](https://github.com/TakuKobayashi/github- exemples-actions / blob / master / .github / workflows / android-debug-build.yml)
• Github Actions fichier de configuration pour Release Build: [android-release-build.yml](https://github.com/TakuKobayashi/github- exemples-actions / blob / master / .github / workflows / android-release-build.yml)
• app/build.gradle

Diverses explications

Configuration JDK

Créez une application Android en tant qu'application Java. Cette fois, nous utiliserons JDK pour construire (même si nous développons avec Kotlin) Dans Actions Github, utilisez action / setup-java pour configurer JDK. Je peux. De plus, cette fois, nous allons construire avec Java version 1.8, alors spécifiez la version à utiliser. Décrivez comme suit dans le fichier yml.

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

Configuration du SDK Android

Une fois que vous avez configuré le JDK, l'étape suivante consiste à télécharger et à configurer le ʻAndroid SDK. ʻAndroid SDK est généralement téléchargé par Android Studio, mais cette fois il est exécuté par CLI, donc téléchargez-le par une méthode qui n'utilise pas Android Studio. Téléchargez le fichier zip qui contient le ʻAndroid SDK dans la section Outils de ligne de commande uniquementde [Android Studio](https://developer.android.com/studio). Cefichier zip dépend de la version des outils ʻAndroid SDK. Entrez l'URL qui spécifie la version que vous souhaitez télécharger et utiliser. Le processus suivant est le processus de téléchargement et de décompression du fichier zip.

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

Pour matrix.sdk-tools, spécifiez la valeur de la version de ʻAndroid SDK` ci-dessus. Dans cet exemple, nous utiliserons «4333796».

ʻUne fois que le SDK Android a été téléchargé et décompressé, transmettez les paramètres et les variables d'environnement PATHpour utiliser les outils de plate-formebuild-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/

Puis acceptez lincense pour utiliser ʻAndroid SDK`.

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

Ceci complète les paramètres du «SDK Android» et vous permet de créer des applications Android.

configuration gradle

Utilisez Gradle pour créer l'application sur Android. Les paramètres Gradle sont configurés automatiquement en exécutant gradlew. (Diverses commandes Gradle sont également exécutées en utilisant gradlew), mettez à jour les autorisations afin que le fichier gradlew puisse être exécuté.

chmod +x ./gradlew

(Bonus) Avertissement résolu

Il est configuré pour s'appuyer sur ce qui précède, mais si vous construisez tel quel, Warning apparaîtra, alors créez le fichier suivant pour éviter Warning.

sudo touch /root/.android/repositories.cfg

Debug Build

Lorsque l'environnement de création d'applications Android est prêt, effectuez d'abord Debug Build. Debug Build peut être construit en exécutant la commande suivante.

./gradlew assembleDebug

Une signature est requise pour créer une application Android, mais dans Debug Build, qui ne spécifie pas de clé de signature, elle est générée dans ~ / .android / debug.keystore lorsque ʻAndroid SDK` est installé. La construction est effectuée en utilisant le fichier de clés existant pour le débogage.

【référence】 J'ai vérifié le keystore pour le débogage

Release Build

Dans le cas de Debug Build, la construction a été effectuée à l'aide du fichier de clés de débogage d'Android, mais lors de la distribution de l'application Android construite sur Google Play Store, etc., elle est distribuée par l'application créée avec la clé de signature par défaut. ne peut pas faire. Afin de distribuer, vous pouvez créer une application à distribuer dans le Store en créant vous-même une clé de signature et en construisant avec la clé de signature créée (ici, une telle version est appelée Release Build". Masu) Dans ce qui suit, nous allons vous montrer comment faire Release Build sur Github Actions. Veuillez également vous référer à ici etc. pour créer la clé.

Rendre possible de se référer à la clé utilisée pour la construction

Pour construire en spécifiant la clé de signature créée, elle est appliquée lors de la construction en spécifiant le fichier de clé de signature dans ʻapp / bulk.gradle`.

Pour le moment, les informations de storeFile`` storePassword`` keyAlias`` keyPassword sont requises, spécifiez donc ces informations dans ʻapp / bulk.gradle. Cependant, puisque ces informations sont une variable d'environnement que vous voulez garder secrète et gérer, décrivez les informations ci-dessus dans local.properties qui décrit la variable d'environnement sur Android, et mettez le contenu dans ʻapp / build.gradle. En le chargeant, il sera référencé lors de la construction. (local.properties est répertorié dans .gitignore par défaut)

La description dans «app / bulk.gradle» est la suivante.

build.gradle

Properties properties = new Properties()
def localPropertiesFile = project.rootProject.file('local.properties');
if(!localPropertiesFile.exists()){
    //S'il n'y a pas de fichier localPropertiesFile, créez-le
    localPropertiesFile.createNewFile();
}
properties.load(localPropertiesFile.newDataInputStream())

Dans l'exemple ci-dessus, si local.properties n'existe pas au moment de la construction, créez-en un nouveau et, s'il y en a, chargez le fichier existant pour l'appliquer aux paramètres. (Si vous ne le faites pas, vous obtiendrez une erreur de construction si local.properties n'existe pas (par exemple, lorsque vous faites Debug Build))

Pour appliquer la valeur de lecture de local.properties à la construction lorsque Release Build, écrivez comme suit.

build.gradle

android {
    ...
    signingConfigs {
        release {
            //Décrivez uniquement s'il existe un fichier spécifié
            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
        }
    }
}

À ce stade, définissez les variables d'environnement suivantes dans local.properties.

local.properties

RELEASE_STORE_FILE=Chemin d'accès au fichier de clé de signature(Chemin absolu)Chaîne
RELEASE_STORE_PASSWORD=Enregistrer la chaîne de mot de passe
RELEASE_KEY_ALIAS=Chaîne d'alias de clé
RELEASE_KEY_PASSWORD=Chaîne de mot de passe clé

• Lorsque les paramètres ci-dessus sont appliqués et que vous souhaitez effectuer Release Build localement, décrivez le contenu ci-dessus dans local.properties et décrivez les informations du fichier de clé de signature.

Gestion des clés

Normalement, le fichier de clé de signature est un fichier binaire, vous devez donc l'enregistrer quelque part et l'obtenir ou l'intégrer dans votre projet. Cependant, il existe un problème lié au fait que le fichier de clé de signature est connu de nombreux développeurs.

Donc, cette fois, enregistrez la gestion des clés de signature dans Github Secrets et appliquez-la en tant que variable d'environnement secrète </ font>

clé de signature de build Android base64.keystore

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

RELEASE_STORE_FILE=Chemin d'accès au fichier de clé de signature(Chemin absolu)Chaîne
RELEASE_STORE_PASSWORD=Enregistrer la chaîne de mot de passe
RELEASE_KEY_ALIAS=Chaîne d'alias de clé
RELEASE_KEY_PASSWORD=Chaîne de mot de passe clé

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/