473 lines
14 KiB
Bash
Executable File
473 lines
14 KiB
Bash
Executable File
#!/bin/bash
|
|
# Copyright (C) 2016-2025 Álinson Santos Xavier <isoron@gmail.com>
|
|
# This file is part of Loop Habit Tracker.
|
|
#
|
|
# Loop Habit Tracker is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by the
|
|
# Free Software Foundation, either version 3 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# Loop Habit Tracker is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
# more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
cd "$(dirname "$0")" || exit
|
|
|
|
ADB="${ANDROID_HOME}/platform-tools/adb"
|
|
ANDROID_OUTPUTS_DIR="uhabits-android/build/outputs"
|
|
AVDMANAGER="${ANDROID_HOME}/cmdline-tools/latest/bin/avdmanager"
|
|
AVD_PREFIX="uhabitsTest"
|
|
EMULATOR="${ANDROID_HOME}/emulator/emulator"
|
|
GRADLE="./gradlew --stacktrace --quiet --console=plain"
|
|
GRADLE_LOG="build/gradle-output.log"
|
|
PACKAGE_NAME=org.isoron.uhabits
|
|
SDKMANAGER="${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager"
|
|
VERSION=$(grep versionName uhabits-android/build.gradle.kts | sed -e 's/.*"\([^"]*\)".*/\1/g')
|
|
ATTEMPTS=1
|
|
BOOT_TIMEOUT=360
|
|
case "$(uname -m)" in
|
|
arm64|aarch64) ARCH="arm64-v8a" ;;
|
|
*) ARCH="x86_64" ;;
|
|
esac
|
|
|
|
# Logging
|
|
# -----------------------------------------------------------------------------
|
|
|
|
log_error() {
|
|
local COLOR='\033[1;31m'
|
|
local NC='\033[0m'
|
|
echo -e "$COLOR* $1 $NC"
|
|
}
|
|
|
|
log_info() {
|
|
local COLOR='\033[1;32m'
|
|
local NC='\033[0m'
|
|
echo -e "$COLOR* $1 $NC"
|
|
}
|
|
|
|
log_debug() {
|
|
local COLOR='\033[0;90m'
|
|
local NC='\033[0m'
|
|
echo -e "${COLOR}$1 $NC"
|
|
}
|
|
|
|
run() {
|
|
log_debug "$*"
|
|
"$@"
|
|
}
|
|
|
|
fail() {
|
|
log_error "BUILD FAILED"
|
|
exit 1
|
|
}
|
|
|
|
# Validation
|
|
# -----------------------------------------------------------------------------
|
|
|
|
if [ -z $VERSION ]; then
|
|
log_error "Could not parse app version from: uhabits-android/build.gradle.kts"
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! -f "${ANDROID_HOME}/platform-tools/adb" ]; then
|
|
log_error "ANDROID_HOME is not set correctly; ${ANDROID_HOME}/platform-tools/adb not found"
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! -f "$EMULATOR" ]; then
|
|
log_error "Not found: $EMULATOR"
|
|
exit 1
|
|
fi
|
|
|
|
MISSING_DEPS=0
|
|
IS_MACOS=0
|
|
if [[ "$(uname)" == "Darwin" ]]; then
|
|
IS_MACOS=1
|
|
fi
|
|
|
|
check_cmd() {
|
|
local cmd=$1
|
|
local brew_pkg=$2
|
|
if ! command -v "$cmd" &>/dev/null; then
|
|
if [ $IS_MACOS -eq 1 ] && [ -n "$brew_pkg" ]; then
|
|
log_error "Required command not found: $cmd (try: brew install $brew_pkg)"
|
|
else
|
|
log_error "Required command not found: $cmd"
|
|
fi
|
|
MISSING_DEPS=1
|
|
fi
|
|
}
|
|
|
|
check_cmd flock flock
|
|
check_cmd timeout coreutils
|
|
check_cmd ts moreutils
|
|
check_cmd rsync rsync
|
|
check_cmd pgrep ""
|
|
check_cmd pkill ""
|
|
|
|
if [ $MISSING_DEPS -ne 0 ]; then
|
|
exit 1
|
|
fi
|
|
|
|
|
|
gradle_run() {
|
|
log_debug "./gradlew $*"
|
|
mkdir -p build
|
|
if ! $GRADLE "$@" > "$GRADLE_LOG" 2>&1; then
|
|
log_error "Gradle command failed: $*"
|
|
grep -E "^e:|^w:|^FAILURE|^> " "$GRADLE_LOG" | head -40
|
|
log_error "Full log: $GRADLE_LOG"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Core
|
|
# -----------------------------------------------------------------------------
|
|
|
|
core_build() {
|
|
log_info "Formatting code..."
|
|
gradle_run ktlintFormat || fail
|
|
log_info "Building uhabits-core..."
|
|
gradle_run kotlinUpgradeYarnLock || fail
|
|
gradle_run :uhabits-core:build || fail
|
|
}
|
|
|
|
# Android
|
|
# -----------------------------------------------------------------------------
|
|
|
|
android_accept_licenses() {
|
|
log_info "Accepting Android SDK licenses..."
|
|
yes | run $SDKMANAGER --licenses
|
|
}
|
|
|
|
android_setup() {
|
|
local API=$1
|
|
local AVDNAME=${AVD_PREFIX}${API}
|
|
|
|
(
|
|
flock 10
|
|
|
|
log_info "Stopping Android emulator..."
|
|
while [[ -n $(pgrep -f ${AVDNAME}) ]]; do
|
|
pkill -9 -f ${AVDNAME}
|
|
done
|
|
|
|
log_info "Removing existing Android virtual device..."
|
|
run $AVDMANAGER delete avd --name $AVDNAME
|
|
|
|
log_info "Creating new Android virtual device (API $API)..."
|
|
run $SDKMANAGER --install "system-images;android-$API;google_apis;$ARCH" || return 1
|
|
run $AVDMANAGER create avd \
|
|
--name $AVDNAME \
|
|
--package "system-images;android-$API;google_apis;$ARCH" \
|
|
--device "Nexus 4" || return 1
|
|
|
|
flock -u 10
|
|
) 10>/tmp/uhabitsTest.lock
|
|
}
|
|
|
|
android_launch() {
|
|
local API=$1
|
|
local AVDNAME=${AVD_PREFIX}${API}
|
|
local PORT=6${API}0
|
|
|
|
export ADB="${ANDROID_HOME}/platform-tools/adb -s emulator-${PORT}"
|
|
|
|
if [ -n "$KILL_EMU" ]; then
|
|
log_info "Stopping Android emulator..."
|
|
while [[ -n $(pgrep -f ${AVDNAME}) ]]; do
|
|
pkill -9 -f ${AVDNAME}
|
|
sleep 1
|
|
done
|
|
fi
|
|
|
|
if pgrep -f "${AVDNAME}" > /dev/null; then
|
|
log_info "Emulator already running (API $API), reusing..."
|
|
return 0
|
|
fi
|
|
|
|
log_info "Launching emulator (API $API)..."
|
|
local EMULATOR_LOG="build/emulator-${API}.log"
|
|
$EMULATOR \
|
|
-avd $AVDNAME \
|
|
-port $PORT \
|
|
-no-snapshot \
|
|
1>"$EMULATOR_LOG" 2>&1 &
|
|
|
|
log_info "Waiting for emulator to boot..."
|
|
timeout $BOOT_TIMEOUT $ADB wait-for-device shell \
|
|
'while [[ -z "$(getprop sys.boot_completed)" ]]; do sleep 1; done; input keyevent 82' &
|
|
local WAIT_PID=$!
|
|
|
|
while kill -0 $WAIT_PID 2>/dev/null; do
|
|
if grep -q "FATAL" "$EMULATOR_LOG" 2>/dev/null; then
|
|
log_error "Emulator crashed:"
|
|
grep "FATAL" "$EMULATOR_LOG"
|
|
kill $WAIT_PID 2>/dev/null
|
|
wait $WAIT_PID 2>/dev/null
|
|
return 1
|
|
fi
|
|
sleep 2
|
|
done
|
|
|
|
wait $WAIT_PID
|
|
if [ $? -ne 0 ]; then
|
|
log_error "Emulator failed to boot after $BOOT_TIMEOUT seconds."
|
|
return 1
|
|
fi
|
|
|
|
log_info "Disabling animations..."
|
|
run $ADB root || return 1
|
|
sleep 5
|
|
run $ADB shell settings put global window_animation_scale 0 || return 1
|
|
run $ADB shell settings put global transition_animation_scale 0 || return 1
|
|
run $ADB shell settings put global animator_duration_scale 0 || return 1
|
|
|
|
log_info "Acquiring wake lock..."
|
|
run $ADB shell 'echo android-test > /sys/power/wake_lock' || return 1
|
|
}
|
|
|
|
# shellcheck disable=SC2016
|
|
android_test() {
|
|
API=$1
|
|
AVDNAME=${AVD_PREFIX}${API}
|
|
|
|
android_launch $API || return 1
|
|
|
|
if [ -n "$RELEASE" ]; then
|
|
log_info "Installing release APK..."
|
|
run $ADB install -r ${ANDROID_OUTPUTS_DIR}/apk/release/uhabits-android-release.apk || return 1
|
|
else
|
|
log_info "Installing debug APK..."
|
|
run $ADB install -t -r ${ANDROID_OUTPUTS_DIR}/apk/debug/uhabits-android-debug.apk || return 1
|
|
fi
|
|
log_info "Installing test APK..."
|
|
run $ADB install -r ${ANDROID_OUTPUTS_DIR}/apk/androidTest/debug/uhabits-android-debug-androidTest.apk || return 1
|
|
|
|
for size in medium large; do
|
|
OUT_INSTRUMENT=${ANDROID_OUTPUTS_DIR}/instrument-${API}.txt
|
|
OUT_LOGCAT=${ANDROID_OUTPUTS_DIR}/logcat-${API}.txt
|
|
FAILED_TESTS=""
|
|
for ((i=1; i<=ATTEMPTS; i++)); do
|
|
log_info "Running $size instrumented tests (attempt $i)..."
|
|
$ADB shell am instrument \
|
|
-r -e coverage true -e size "$size" $FAILED_TESTS \
|
|
-w ${PACKAGE_NAME}.test/androidx.test.runner.AndroidJUnitRunner \
|
|
| ts "%.s" > "$OUT_INSTRUMENT"
|
|
|
|
FAILED_TESTS=$(tools/parseInstrument.py "$OUT_INSTRUMENT")
|
|
SUCCESS=$?
|
|
log_debug "$FAILED_TESTS"
|
|
if [ $SUCCESS -eq 0 ]; then
|
|
log_info "$size tests passed."
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ $SUCCESS -ne 0 ]; then
|
|
log_error "Some $size instrumented tests failed."
|
|
log_error "Saving logcat: $OUT_LOGCAT..."
|
|
$ADB logcat -d > $OUT_LOGCAT
|
|
log_error "Fetching test screenshots..."
|
|
run $ADB pull /sdcard/Android/data/${PACKAGE_NAME}/files/test-screenshots ${ANDROID_OUTPUTS_DIR}/
|
|
run $ADB shell rm -r /sdcard/Android/data/${PACKAGE_NAME}/files/test-screenshots/
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
return 0
|
|
}
|
|
|
|
android_test_parallel() {
|
|
# Launch background processes
|
|
PIDS=""
|
|
for API in $*; do
|
|
(
|
|
LOG=build/android-test-$API.log
|
|
mkdir -p build
|
|
log_info "API $API: Running tests..."
|
|
android_test $API 1>$LOG 2>&1
|
|
ret_code=$?
|
|
if [ $ret_code = 0 ]; then
|
|
log_info "API $API: Passed"
|
|
else
|
|
log_error "API $API: Failed"
|
|
fi
|
|
pkill -9 -f ${AVD_PREFIX}${API}
|
|
exit $ret_code
|
|
)&
|
|
PIDS+=" $!"
|
|
done
|
|
|
|
# Check exit codes
|
|
success=0
|
|
for pid in $PIDS; do
|
|
wait $pid
|
|
ret_code=$?
|
|
if [ $ret_code != 0 ]; then
|
|
success=1
|
|
fi
|
|
done
|
|
|
|
# Print all logs
|
|
for API in $*; do
|
|
echo "::group::Android Tests (API $API)"
|
|
cat build/android-test-$API.log
|
|
echo "::endgroup::"
|
|
done
|
|
|
|
return $success
|
|
}
|
|
|
|
android_build() {
|
|
log_info "Building uhabits-android..."
|
|
|
|
if [ -n "$RELEASE" ]; then
|
|
log_info "Reading secret..."
|
|
# shellcheck disable=SC1091
|
|
source .secret/env || fail
|
|
fi
|
|
|
|
log_info "Removing old APKs..."
|
|
rm -f uhabits-android/build/*.apk
|
|
|
|
if [ -n "$RELEASE" ]; then
|
|
log_info "Building release APK..."
|
|
gradle_run updateTranslators
|
|
gradle_run :uhabits-android:assembleRelease
|
|
log_info "Copying release APK..."
|
|
cp uhabits-android/build/outputs/apk/release/uhabits-android-release.apk \
|
|
uhabits-android/build/loop-"$VERSION"-release.apk
|
|
fi
|
|
|
|
log_info "Building debug APK..."
|
|
gradle_run :uhabits-android:assembleDebug || fail
|
|
log_info "Copying debug APK..."
|
|
cp uhabits-android/build/outputs/apk/debug/uhabits-android-debug.apk \
|
|
uhabits-android/build/loop-"$VERSION"-debug.apk
|
|
|
|
log_info "Building instrumentation APK..."
|
|
if [ -n "$RELEASE" ]; then
|
|
gradle_run :uhabits-android:assembleAndroidTest \
|
|
-Pandroid.injected.signing.store.file="$LOOP_KEY_STORE" \
|
|
-Pandroid.injected.signing.store.password="$LOOP_STORE_PASSWORD" \
|
|
-Pandroid.injected.signing.key.alias="$LOOP_KEY_ALIAS" \
|
|
-Pandroid.injected.signing.key.password="$LOOP_KEY_PASSWORD" || fail
|
|
else
|
|
gradle_run assembleAndroidTest || fail
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
android_accept_images() {
|
|
log_info "Accepting test screenshots..."
|
|
run find ${ANDROID_OUTPUTS_DIR}/test-screenshots -name '*.expected*' -delete
|
|
run rsync -av ${ANDROID_OUTPUTS_DIR}/test-screenshots/ uhabits-android/src/androidTest/assets/
|
|
}
|
|
|
|
# General
|
|
# -----------------------------------------------------------------------------
|
|
|
|
_parse_opts() {
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
-r ) RELEASE=1; shift ;;
|
|
-c ) CLEAN=1; shift ;;
|
|
-k ) KILL_EMU=1; shift ;;
|
|
-n ) ATTEMPTS=$2; shift 2 ;;
|
|
* ) shift ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
_print_usage() {
|
|
cat <<END
|
|
CI/CD script for Loop Habit Tracker.
|
|
|
|
Usage:
|
|
build.sh build [options]
|
|
build.sh android-accept-licenses
|
|
build.sh android-setup <API>
|
|
build.sh android-tests <API> [options]
|
|
build.sh android-tests-parallel <API> <API>... [options]
|
|
build.sh android-accept-images [options]
|
|
|
|
Commands:
|
|
build Build the app and run small tests
|
|
android-accept-licenses Accept all Android SDK licenses
|
|
android-setup Create Android virtual machine
|
|
android-tests Run medium and large Android tests on an emulator
|
|
android-tests-parallel Tests multiple API levels simultaneously
|
|
android-accept-images Copy fetched images to corresponding assets folder
|
|
|
|
Options:
|
|
-c Remove build folders before building
|
|
-k Kill running emulator before tests (default: reuse if running)
|
|
-n N Number of test attempts per size (default: 1)
|
|
-r Build and test release version, instead of debug
|
|
END
|
|
}
|
|
|
|
clean() {
|
|
log_info "Cleaning build folders..."
|
|
rm -rf uhabits-android/.gradle
|
|
rm -rf uhabits-android/android-pickers/build
|
|
rm -rf uhabits-android/build
|
|
rm -rf uhabits-android/uhabits-android/build
|
|
rm -rf uhabits-core-legacy/.gradle
|
|
rm -rf uhabits-core-legacy/build
|
|
rm -rf uhabits-core/.gradle
|
|
rm -rf uhabits-core/build
|
|
rm -rf uhabits-server/.gradle
|
|
rm -rf uhabits-server/build
|
|
rm -rf uhabits-web/build
|
|
rm -rf uhabits-web/node_modules
|
|
rm -rf uhabits-web/node_modules/core-js/build
|
|
rm -rf uhabits-web/node_modules/upath/build
|
|
rm -rf .gradle
|
|
}
|
|
|
|
main() {
|
|
case "$1" in
|
|
build)
|
|
shift; _parse_opts "$@"
|
|
if [ -n "$CLEAN" ]; then clean; fi
|
|
core_build
|
|
android_build
|
|
;;
|
|
android-accept-licenses)
|
|
android_accept_licenses
|
|
;;
|
|
android-setup)
|
|
shift; _parse_opts "$@"
|
|
android_setup $1
|
|
;;
|
|
android-tests)
|
|
shift; _parse_opts "$@"
|
|
if [ -z $1 ]; then
|
|
_print_usage
|
|
exit 1
|
|
fi
|
|
android_test $1
|
|
;;
|
|
android-tests-parallel)
|
|
shift; _parse_opts "$@"
|
|
android_test_parallel $*
|
|
;;
|
|
android-accept-images)
|
|
android_accept_images
|
|
;;
|
|
*)
|
|
_print_usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|