install_linux.sh

#!/usr/bin/env bash

REPO="https://github.com/BasGame1/apk2kotlin.git"
REPO_FOLDER="apk2kotlin"

JADX_REPO="https://github.com/skylot/jadx/releases/download/v1.5.1/jadx-1.5.1.zip"
APKTOOL_JAR_REPO="https://github.com/iBotPeaches/Apktool/releases/download/v2.10.0/apktool_2.10.0.jar"
APKTOOL_SCRIPT_REPO="https://raw.githubusercontent.com/iBotPeaches/Apktool/master/scripts/linux/apktool"

# Detect OS and Architecture
OS_TYPE="$(uname -s)"
ARCH_TYPE="$(uname -m)"
IS_TERMUX=false

if [ -n "$PREFIX" ] && [[ "$PREFIX" == *"com.termux"* ]]; then
    IS_TERMUX=true
fi

# via the os download the correct one
case "$OS_TYPE" in
    Linux)
        if $IS_TERMUX; then
            OPT_DIR="$HOME/opt"
            NDK_REPO="https://dl.google.com/android/repository/android-ndk-r29-linux.zip"
            MINGW_REPO="https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-ubuntu-20.04-x86_64.tar.xz"
            ARM_GCC_REPO="https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-linux-gnu.tar.xz"
        else
            OPT_DIR="/opt"
            NDK_REPO="https://dl.google.com/android/repository/android-ndk-r29-linux.zip"
            MINGW_REPO="https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-ubuntu-20.04-x86_64.tar.xz"
            ARM_GCC_REPO="https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-linux-gnu.tar.xz"
        fi
        ;;
    Darwin)
        OPT_DIR="$HOME/opt"
        NDK_REPO="https://dl.google.com/android/repository/android-ndk-r29-darwin.share"
        MINGW_REPO="https://github.com/mstorsjo/llvm-mingw/releases/download/20240619/llvm-mingw-20240619-ucrt-macos-universal.tar.xz"
        if [ "$ARCH_TYPE" = "arm64" ]; then
            ARM_GCC_REPO="https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-darwin-arm64-aarch64-none-linux-gnu.tar.xz"
        else
            ARM_GCC_REPO="https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-darwin-x86_64-aarch64-none-linux-gnu.tar.xz"
        fi
        ;;
    *)
        echo "Unsupported OS kernel: $OS_TYPE"
        exit 1
        ;;
esac

MINGW_VERSION="mingw_toolchain.tar.xz"
NDK_VERSION="ndk_toolchain.zip"
ARM_GCC_VERSION="arm_gcc_toolchain.tar.xz"

NUMBERS='^[0-9]+$'
i=0

error() { echo -e "\033[0;31m$1\033[0m"; }
success() { echo -e "\033[0;32m$1\033[0m"; }
info() { echo -e "\033[1;33m$1\033[0m"; }
error_fatal() { echo -e "\033[0;31m$1\033[0m"; exit 255; }

SUDO_CMD=""
if ! $IS_TERMUX && [ "$OS_TYPE" = "Linux" ] && [ "$EUID" -ne 0 ]; then
    SUDO_CMD="sudo"
fi

BIN_DIR="/usr/local/bin"
if $IS_TERMUX; then
    BIN_DIR="$PREFIX/bin"
elif [ "$EUID" -ne 0 ] && [ -z "$SUDO_CMD" ]; then
    BIN_DIR="$HOME/.local/bin"
    mkdir -p "$BIN_DIR"
fi

help_menu() {
    info "---------------------HELP MENU ($OS_TYPE)-----------------------"
    echo "Usage: $0 [-a] [-m] [-n] [-j] [-k] [-o] [-h]"
    echo "  -a : Install ARM GCC toolchain (Linux ARM64)"
    echo "  -m : Install LLVM-MinGW (Windows x86_64 & ARM64)"
    echo "  -n : Install Android NDK (Android ARM64 & x86_64)"
    echo "  -j : Install JADX"
    echo "  -k : Install Apktool"
    echo "  -o : Open interactive options menu"
    echo "  -h : Show help menu"
    info "-------------------------------------------------------------"
}

check_repo() {
    [ -f "Makefile" ] || [ -d "src" ] || ([ -d "$REPO_FOLDER" ] && [ -f "$REPO_FOLDER/Makefile" ])
}

install_repo() {
    local target_folder="$REPO_FOLDER"
    while [ -d "$target_folder" ]; do
        i=$((i + 1))
        target_folder="${REPO_FOLDER}_${i}"
    done
    info "Cloning repository to $target_folder..."
    git clone "$REPO" "$target_folder"
    REPO_FOLDER="$target_folder"
}

install_mingw() {
    info "Downloading LLVM-MinGW for $OS_TYPE..."
    curl -L -o "$MINGW_VERSION" "$MINGW_REPO"
    info "Extracting LLVM-MinGW to $OPT_DIR/llvm-mingw..."
    $SUDO_CMD mkdir -p "$OPT_DIR/llvm-mingw"
    $SUDO_CMD tar -xf "$MINGW_VERSION" -C "$OPT_DIR/llvm-mingw" --strip-components=1
    rm -f "$MINGW_VERSION"
    success "LLVM-MinGW installed successfully."
}

install_ndk() {
    info "Downloading Android NDK for $OS_TYPE..."
    curl -L -o "$NDK_VERSION" "$NDK_REPO"
    info "Extracting Android NDK to $OPT_DIR/android-ndk..."
    $SUDO_CMD mkdir -p "$OPT_DIR/android-ndk"
    mkdir -p /tmp/ndk_extract 2>/dev/null || mkdir -p "$HOME/tmp/ndk_extract"
    TMP_NDK_DIR="$(mktemp -d)"
    unzip -q -o "$NDK_VERSION" -d "$TMP_NDK_DIR"
    $SUDO_CMD cp -r "$TMP_NDK_DIR"/*/* "$OPT_DIR/android-ndk/"
    rm -rf "$TMP_NDK_DIR" "$NDK_VERSION"
    success "Android NDK installed successfully."
}

install_arm_gcc() {
    info "Downloading ARM Linux GCC toolchain for $OS_TYPE..."
    curl -L -o "$ARM_GCC_VERSION" "$ARM_GCC_REPO"
    info "Extracting ARM GCC to $OPT_DIR/aarch64-linux-gnu..."
    $SUDO_CMD mkdir -p "$OPT_DIR/aarch64-linux-gnu"
    $SUDO_CMD tar -xf "$ARM_GCC_VERSION" -C "$OPT_DIR/aarch64-linux-gnu" --strip-components=1
    rm -f "$ARM_GCC_VERSION"
    success "ARM Linux GCC toolchain installed successfully."
}

install_jadx() {
    info "Downloading JADX..."
    curl -L -o "jadx.zip" "$JADX_REPO"
    info "Extracting JADX to $OPT_DIR/jadx..."
    $SUDO_CMD mkdir -p "$OPT_DIR/jadx"
    $SUDO_CMD unzip -q -o "jadx.zip" -d "$OPT_DIR/jadx"
    rm -f "jadx.zip"
    $SUDO_CMD chmod +x "$OPT_DIR/jadx/bin/jadx"
    $SUDO_CMD ln -sf "$OPT_DIR/jadx/bin/jadx" "$BIN_DIR/jadx"
    if [ -f "$OPT_DIR/jadx/bin/jadx-gui" ]; then
        $SUDO_CMD chmod +x "$OPT_DIR/jadx/bin/jadx-gui"
        $SUDO_CMD ln -sf "$OPT_DIR/jadx/bin/jadx-gui" "$BIN_DIR/jadx-gui"
    fi
    success "JADX installed successfully to $BIN_DIR/jadx."
}

install_apktool() {
    info "Downloading Apktool launcher and binary..."
    curl -L -o "apktool" "$APKTOOL_SCRIPT_REPO"
    curl -L -o "apktool.jar" "$APKTOOL_JAR_REPO"
    chmod +x "apktool"
    $SUDO_CMD mkdir -p "$OPT_DIR/apktool"
    $SUDO_CMD mv "apktool" "$OPT_DIR/apktool/apktool"
    $SUDO_CMD mv "apktool.jar" "$OPT_DIR/apktool/apktool.jar"
    $SUDO_CMD ln -sf "$OPT_DIR/apktool/apktool" "$BIN_DIR/apktool"
    success "Apktool installed successfully to $BIN_DIR/apktool."
}

install_host_gcc() {
    info "Checking native host C compiler ($OS_TYPE)..."
    if command -v gcc &>/dev/null || command -v clang &>/dev/null; then
        success "Host compiler is available."
        return 0
    fi

    if $IS_TERMUX; then
        pkg install -y clang make git unzip curl
    elif [ "$OS_TYPE" = "Darwin" ]; then
        xcode-select --install
    elif [ "$OS_TYPE" = "Linux" ]; then
        if command -v pacman &>/dev/null; then $SUDO_CMD pacman -S --needed --noconfirm gcc make git unzip curl
        elif command -v apt-get &>/dev/null; then $SUDO_CMD apt-get update && $SUDO_CMD apt-get install -y build-essential git unzip curl
        elif command -v dnf &>/dev/null; then $SUDO_CMD dnf install -y gcc make git unzip curl
        elif command -v zypper &>/dev/null; then $SUDO_CMD zypper in -y gcc make git unzip curl
        elif command -v apk &>/dev/null; then $SUDO_CMD apk add build-base git unzip curl
        fi
    fi
}

options_menu() {
    info "---------------------OPTIONS MENU-----------------------"
    echo "1: Install LLVM-MinGW (Windows x86_64 & ARM64)"
    echo "2: Install Android NDK (Android x86_64 & ARM64)"
    echo "3: Install ARM GCC toolchain (Linux ARM64)"
    echo "4: Install Host C Compiler ($OS_TYPE)"
    echo "5: Install JADX"
    echo "6: Install Apktool"
    echo "7: Install all toolchains & tools"
    echo "8: Clone repository"
    echo "9: Build all binaries"
    echo "10: Help menu"
    echo "11: Exit"
    info "--------------------------------------------------------"
    read -rp "Select option [1-11]: " OPTIONS_MENU_SELECTION

    case "$OPTIONS_MENU_SELECTION" in
        1) install_mingw; options_menu ;;
        2) install_ndk; options_menu ;;
        3) install_arm_gcc; options_menu ;;
        4) install_host_gcc; options_menu ;;
        5) install_jadx; options_menu ;;
        6) install_apktool; options_menu ;;
        7) install_host_gcc; install_arm_gcc; install_mingw; install_ndk; install_jadx; install_apktool; options_menu ;;
        8) check_repo || install_repo; options_menu ;;
        9)
            [ -d "$REPO_FOLDER" ] && cd "$REPO_FOLDER"
            [ -f "Makefile" ] || error_fatal "Makefile not found."
            make all && success "Build completed successfully." && exit 0
            ;;
        10) help_menu; options_menu ;;
        11) exit 0 ;;
        *) error_fatal "Invalid option." ;;
    esac
}

# args
if [ -n "$1" ]; then
    while getopts "anmjkho" OPTION; do
        case "$OPTION" in
            a) install_arm_gcc ;;
            n) install_ndk ;;
            m) install_mingw ;;
            j) install_jadx ;;
            k) install_apktool ;;
            o) options_menu; exit 0 ;;
            h) help_menu; exit 0 ;;
            *) help_menu; exit 1 ;;
        esac
    done
fi

# default option (no args)
install_host_gcc

[ ! -d "$OPT_DIR/android-ndk" ] && install_ndk
[ ! -d "$OPT_DIR/llvm-mingw" ] && install_mingw
[ ! -d "$OPT_DIR/aarch64-linux-gnu" ] && install_arm_gcc
[ ! -d "$OPT_DIR/jadx" ] && install_jadx
[ ! -d "$OPT_DIR/apktool" ] && install_apktool

if ! check_repo; then
    install_repo
fi

[ -d "$REPO_FOLDER" ] && cd "$REPO_FOLDER"

if [ -f "Makefile" ]; then
    info "Makefile detected. Compiling all target binaries..."
    make all && success "Build completed successfully!"
else
    error_fatal "No Makefile found to build binaries."
fi