install_avd.sh

#!/usr/bin/env bash
# Install a shared Android AVD from a Hugging Face dataset on an Apple Silicon Mac.
#
# Usage:
#   bash install_avd.sh [AVD_NAME] [--launch] [--force]
#
#   AVD_NAME   AVD stored in the dataset (default: MineAndroid)
#   --launch   Start the emulator after installing
#   --force    Back up and replace an existing local AVD with the same name
#
# Environment:
#   AVD_REPO          Hugging Face dataset (default: yanhhh/AndroidAvd)
#   ANDROID_HOME      Android SDK (default: ~/Library/Android/sdk)
#   ANDROID_AVD_HOME  AVD directory (default: ~/.android/avd)
#   HF_TOKEN          Read token for a private dataset; public datasets need none
set -euo pipefail

REPO="${AVD_REPO:-yanhhh/AndroidAvd}"
NAME="MineAndroid"
LAUNCH=0
FORCE=0
for arg in "$@"; do
  case "$arg" in
    --launch) LAUNCH=1 ;;
    --force) FORCE=1 ;;
    -h|--help) sed -n '2,15p' "$0"; exit 0 ;;
    -*) echo "Unknown option: $arg" >&2; exit 2 ;;
    *) NAME="$arg" ;;
  esac
done

SYSTEM_IMAGE="system-images;android-33;google_apis;arm64-v8a"
SYSTEM_IMAGE_DIR="system-images/android-33/google_apis/arm64-v8a"
EXPECTED_REVISION=17

log()  { printf '\033[1;34m==>\033[0m %s\n' "$*"; }
warn() { printf '\033[1;33mWarning:\033[0m %s\n' "$*" >&2; }
die()  { printf '\033[1;31mError:\033[0m %s\n' "$*" >&2; exit 1; }

[ "$(uname -s)" = Darwin ] && [ "$(uname -m)" = arm64 ] \
  || die "This AVD uses arm64-v8a and requires an Apple Silicon Mac"

SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-$HOME/Library/Android/sdk}}"
AVD_HOME="${ANDROID_AVD_HOME:-$HOME/.android/avd}"
CACHE="${XDG_CACHE_HOME:-$HOME/.cache}/android-avd-share/${REPO//\//__}"
TARGET="$AVD_HOME/$NAME.avd"
EMULATOR="$SDK/emulator/emulator"

free_gb=$(df -g "$HOME" | awk 'NR==2 {print $4}')
[ "$free_gb" -ge 30 ] || warn "Only ${free_gb} GB free; the AVD, system image and emulator need about 25 GB"

# ---------- Android SDK: emulator + system image ----------

ensure_java() {
  [ -n "${JAVA_HOME:-}" ] && return
  local studio_jbr="/Applications/Android Studio.app/Contents/jbr/Contents/Home"
  if [ -x "$studio_jbr/bin/java" ]; then
    export JAVA_HOME="$studio_jbr"
  elif /usr/libexec/java_home -v 17+ >/dev/null 2>&1; then
    JAVA_HOME="$(/usr/libexec/java_home -v 17+)"; export JAVA_HOME
  elif command -v brew >/dev/null; then
    log "Installing OpenJDK 17 for sdkmanager"
    brew install openjdk@17
    JAVA_HOME="$(brew --prefix openjdk@17)/libexec/openjdk.jdk/Contents/Home"; export JAVA_HOME
  else
    die "sdkmanager needs Java 17+; install Android Studio or Homebrew first"
  fi
}

find_sdkmanager() {
  local candidate
  for candidate in "$SDK/cmdline-tools/latest/bin/sdkmanager" "$SDK"/cmdline-tools/*/bin/sdkmanager \
                   "$(command -v sdkmanager 2>/dev/null || true)"; do
    if [ -n "$candidate" ] && [ -x "$candidate" ]; then
      echo "$candidate"
      return 0
    fi
  done
  return 1
}

if [ ! -x "$EMULATOR" ] || [ ! -f "$SDK/$SYSTEM_IMAGE_DIR/source.properties" ]; then
  log "Installing Android emulator and $SYSTEM_IMAGE into $SDK"
  ensure_java
  if ! SDKMANAGER="$(find_sdkmanager)"; then
    command -v brew >/dev/null || die "Install Android Studio or Homebrew, then rerun this script"
    brew install --cask android-commandlinetools
    SDKMANAGER="$(find_sdkmanager)" || die "sdkmanager is still unavailable"
  fi
  mkdir -p "$SDK"
  yes | "$SDKMANAGER" --sdk_root="$SDK" --licenses >/dev/null || true
  "$SDKMANAGER" --sdk_root="$SDK" "platform-tools" "emulator" "$SYSTEM_IMAGE"
fi

revision="$(sed -n 's/^Pkg.Revision=//p' "$SDK/$SYSTEM_IMAGE_DIR/source.properties")"
[ "${revision%%.*}" = "$EXPECTED_REVISION" ] \
  || warn "System image revision is $revision; this AVD was built on revision $EXPECTED_REVISION and may not boot"

# ---------- Hugging Face download ----------

if command -v hf >/dev/null; then
  HF=(hf)
elif command -v uvx >/dev/null; then
  HF=(uvx --from "huggingface_hub>=1.30" hf)
elif command -v brew >/dev/null; then
  brew install hf
  HF=(hf)
else
  die "Install the Hugging Face CLI first: brew install hf"
fi

download() {
  "${HF[@]}" download "$REPO" --repo-type dataset \
    --include "$NAME.ini" --include "$NAME.avd/*" --local-dir "$CACHE"
}

log "Downloading $NAME from $REPO (resumable; cached in $CACHE)"
mkdir -p "$CACHE"
if ! download; then
  [ -z "${HF_TOKEN:-}" ] || die "Download failed; check that HF_TOKEN can read $REPO"
  log "Log in with a Hugging Face read token that can access $REPO"
  "${HF[@]}" auth login --force
  download || die "Download failed; check the repository name and your access"
fi
[ -f "$CACHE/$NAME.avd/config.ini" ] || die "$NAME.avd was not found in $REPO"

# ---------- Install into the AVD directory ----------

if pgrep -qf -- "-avd $NAME( |$)"; then
  die "Emulator $NAME is running; close it and rerun"
fi

mkdir -p "$AVD_HOME"
if [ -e "$TARGET" ]; then
  [ "$FORCE" = 1 ] || die "$TARGET already exists; rerun with --force to back it up and replace it"
  backup="$TARGET.bak-$(date +%Y%m%d%H%M%S)"
  log "Backing up existing AVD to $backup"
  mv "$TARGET" "$backup"
fi

log "Installing to $TARGET"
if ! cp -cR "$CACHE/$NAME.avd" "$TARGET" 2>/dev/null; then
  rm -rf "$TARGET"
  cp -R "$CACHE/$NAME.avd" "$TARGET"
fi

rm -rf "$TARGET/snapshots" "$TARGET/tmpAdbCmds"
rm -f "$TARGET"/*.lock "$TARGET/hardware-qemu.ini" "$TARGET/emu-launch-params.txt" \
      "$TARGET/bootcompleted.ini" "$TARGET/read-snapshot.txt" "$TARGET/snapshot.trace"

target_api="$(sed -n 's/^target=//p' "$CACHE/$NAME.ini")"
cat > "$AVD_HOME/$NAME.ini" <<EOF
avd.ini.encoding=UTF-8
path=$TARGET
path.rel=avd/$NAME.avd
target=${target_api:-android-33}
EOF

CONFIG="$TARGET/config.ini"
sed -i '' -E \
  -e "s#/Users/[^/]+/Library/Android/sdk#$SDK#g" \
  -e "s#/Users/[^/]+/\.android/avd#$AVD_HOME#g" \
  "$CONFIG"
skin="$(sed -n 's/^skin.name=//p' "$CONFIG")"
if [ -n "$skin" ] && [ ! -d "$SDK/skins/$skin" ]; then
  sed -i '' -e '/^skin\.name=/d' -e '/^skin\.path=/d' "$CONFIG"
  log "Skin $skin is not installed; using the default emulator frame"
fi

if grep -q "/Users/" "$CONFIG" && grep "/Users/" "$CONFIG" | grep -vq "$HOME"; then
  warn "config.ini still references another user's path:"
  grep "/Users/" "$CONFIG" | grep -v "$HOME" >&2
fi

"$EMULATOR" -list-avds 2>/dev/null | grep -qx "$NAME" || die "The emulator does not list $NAME; check $AVD_HOME/$NAME.ini"

log "Installed $NAME"
if [ "$LAUNCH" = 1 ]; then
  exec "$EMULATOR" -avd "$NAME" -no-snapshot-load
fi
cat <<EOF

Start it with:
  "$EMULATOR" -avd $NAME -no-snapshot-load

Add -read-only to discard changes after each session. Do not use -wipe-data; it erases the installed apps.
EOF