eric/FTC-Project-Gen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f69870b87f0783c4c7d1cc64555c6370e986e719
FTC-Project-Gen/linux/lib.sh
Eric Ratliff f69870b87f Really good
2026-01-24 13:12:14 -06:00

623 lines
22 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
# FTC Project Generator - Shared Library Functions
# Copyright (c) 2026 Nexus Workshops LLC
# Licensed under MIT License
# Get the directory where this script lives
get_script_dir() {
echo "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
}
# Get generator version
get_generator_version() {
local script_dir="$(get_script_dir)"
local version_file="$script_dir/../VERSION"
if [ -f "$version_file" ]; then
cat "$version_file" | tr -d '\n\r'
else
echo "unknown"
fi
}
# Process template file, replacing placeholders
process_template() {
local input="$1"
local output="$2"
sed -e "s|{{PROJECT_NAME}}|${PROJECT_NAME}|g" \
-e "s|{{SDK_DIR}}|${FTC_SDK_DIR}|g" \
-e "s|{{FTC_VERSION}}|${FTC_VERSION}|g" \
-e "s|{{GENERATOR_VERSION}}|${GENERATOR_VERSION}|g" \
"$input" > "$output"
}
# Copy template file
copy_template() {
local src="$1"
local dest="$2"
cp "$src" "$dest"
}
# Create project structure
create_project_structure() {
local project_dir="$1"
mkdir -p "$project_dir"
cd "$project_dir"
mkdir -p src/main/java/robot/subsystems
mkdir -p src/main/java/robot/hardware
mkdir -p src/main/java/robot/opmodes
mkdir -p src/test/java/robot/subsystems
mkdir -p src/test/java/robot/hardware
mkdir -p gradle/wrapper
}
# Install all project templates
install_templates() {
local project_dir="$1"
local template_dir="$2"
cd "$project_dir"
copy_template "$template_dir/Pose2d.java" "src/main/java/robot/Pose2d.java"
copy_template "$template_dir/Drive.java" "src/main/java/robot/subsystems/Drive.java"
copy_template "$template_dir/MecanumDrive.java" "src/main/java/robot/hardware/MecanumDrive.java"
copy_template "$template_dir/TeleOp.java" "src/main/java/robot/opmodes/TeleOp.java"
copy_template "$template_dir/DriveTest.java" "src/test/java/robot/subsystems/DriveTest.java"
copy_template "$template_dir/build.gradle.kts" "build.gradle.kts"
process_template "$template_dir/settings.gradle.kts.template" "settings.gradle.kts"
process_template "$template_dir/gitignore.template" ".gitignore"
process_template "$template_dir/README.md.template" "README.md"
copy_template "$template_dir/build.sh" "build.sh"
chmod +x "build.sh"
create_deploy_script "$project_dir"
echo "${GENERATOR_VERSION}" > ".ftc-generator-version"
}
# Create deploy script
create_deploy_script() {
local project_dir="$1"
cat > "$project_dir/deploy-to-robot.sh" <<'ENDSCRIPT'
#!/bin/bash
set -e
CONTROL_HUB_IP="${CONTROL_HUB_IP:-192.168.43.1}"
CONTROL_HUB_PORT="5555"
while [[ $# -gt 0 ]]; do
case $1 in
-h|--help)
echo "════════════════════════════════════════════════════════════════"
echo " Deploy FTC Project to Control Hub"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "Usage: $0 [options]"
echo ""
echo "Options:"
echo " --usb Force USB connection"
echo " --wifi Force WiFi Direct connection"
echo " -i, --ip <ip> Custom Control Hub IP"
echo " -h, --help Show this help"
echo ""
echo "Examples:"
echo " $0 # Auto-detect connection"
echo " $0 --usb # Use USB only"
echo " $0 --wifi # Use WiFi Direct"
echo " $0 -i 192.168.1.5 # Custom IP"
echo ""
exit 0
;;
-i|--ip) CONTROL_HUB_IP="$2"; shift 2 ;;
--usb) FORCE_USB=true; shift ;;
--wifi) FORCE_WIFI=true; shift ;;
*) shift ;;
esac
done
echo "════════════════════════════════════════════════════════════════"
echo " FTC Project Deployment"
echo "════════════════════════════════════════════════════════════════"
echo ""
# Step 1: Deploy code to SDK
echo "Step 1: Deploying code to SDK TeamCode..."
if ! ./gradlew deployToSDK; then
echo ""
echo "Error: Failed to deploy code"
echo "Make sure you're in the project directory"
exit 1
fi
echo "✓ Code deployed"
echo ""
# Step 2: Build APK
echo "Step 2: Building APK..."
SDK_DIR="${HOME}/ftc-sdk"
if [ ! -d "$SDK_DIR" ]; then
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " Error: FTC SDK Not Found"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "The FTC SDK should be at: $SDK_DIR"
echo ""
echo "This should have been set up when you created the project."
echo ""
echo "To fix:"
echo " git clone --depth 1 --branch v10.1.1 \\"
echo " https://github.com/FIRST-Tech-Challenge/FtcRobotController.git \\"
echo " ~/ftc-sdk"
echo ""
exit 1
fi
cd "$SDK_DIR" || exit 1
# Check for Android SDK configuration
if [ ! -f "local.properties" ] && [ -z "$ANDROID_HOME" ]; then
echo ""
echo "Android SDK not found. Attempting auto-setup..."
# Try to find common Android SDK locations
FOUND_SDK=""
for loc in "$HOME/Android/Sdk" "$HOME/.android-sdk" "$HOME/Library/Android/sdk"; do
if [ -d "$loc" ] && [ -d "$loc/platforms" ]; then
FOUND_SDK="$loc"
break
fi
done
if [ -n "$FOUND_SDK" ]; then
echo "✓ Found Android SDK at $FOUND_SDK"
echo "sdk.dir=$FOUND_SDK" > local.properties
export ANDROID_HOME="$FOUND_SDK"
else
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " Error: Android SDK Not Configured"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "The FTC SDK needs the Android SDK to build APKs."
echo ""
echo "FIX OPTION 1: Run setup automatically"
echo " Create a new project with ftc-new-project (it will set up Android SDK)"
echo ""
echo "FIX OPTION 2: Set ANDROID_HOME manually"
echo " export ANDROID_HOME=/path/to/android/sdk"
echo " echo 'export ANDROID_HOME=/path/to/android/sdk' >> ~/.bashrc"
echo ""
echo "FIX OPTION 3: Create local.properties"
echo " echo 'sdk.dir=/path/to/android/sdk' > ~/ftc-sdk/local.properties"
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " How to Install Android SDK"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "1. Download Android Studio:"
echo " https://developer.android.com/studio"
echo ""
echo "2. Install and open Android Studio"
echo ""
echo "3. Go to: Tools → SDK Manager"
echo ""
echo "4. Note the 'Android SDK Location' path shown"
echo ""
echo "5. Use that path in FIX OPTION 2 or 3 above"
echo ""
echo "Typical Android SDK locations:"
echo " • Linux: ~/Android/Sdk"
echo " • macOS: ~/Library/Android/sdk"
echo " • Windows: C:\\Users\\YourName\\AppData\\Local\\Android\\Sdk"
echo ""
echo "════════════════════════════════════════════════════════════════"
echo ""
exit 1
fi
fi
if ! ./gradlew build; then
echo ""
echo "Error: APK build failed"
echo "Check the error messages above for details"
exit 1
fi
APK_PATH="$SDK_DIR/FtcRobotController/build/outputs/apk/debug/FtcRobotController-debug.apk"
if [ ! -f "$APK_PATH" ]; then
echo ""
echo "Error: APK not found at expected location"
echo "Expected: $APK_PATH"
exit 1
fi
echo "✓ APK built"
echo ""
# Step 3: Install to Control Hub
echo "Step 3: Installing to Control Hub..."
if ! command -v adb &> /dev/null; then
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " Error: adb Command Not Found"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "The 'adb' tool is needed to install APKs to the Control Hub."
echo ""
echo "Install:"
echo " • Ubuntu/Debian: sudo apt install android-tools-adb"
echo " • Arch Linux: sudo pacman -S android-tools"
echo " • macOS: brew install android-platform-tools"
echo ""
echo "Or download Android Platform Tools:"
echo " https://developer.android.com/studio/releases/platform-tools"
echo ""
exit 1
fi
INSTALLED=false
# Try USB first
if [ "$FORCE_WIFI" != "true" ]; then
USB_COUNT=$(adb devices | grep -v "List" | grep "device$" | wc -l)
if [ "$USB_COUNT" -gt 0 ]; then
echo "✓ Control Hub connected via USB"
if adb install -r "$APK_PATH"; then
INSTALLED=true
fi
elif [ "$FORCE_USB" = "true" ]; then
echo ""
echo "Error: No USB device found (--usb specified)"
echo ""
echo "Make sure:"
echo " • Control Hub is powered on"
echo " • USB cable is connected"
echo " • USB debugging is enabled"
echo ""
exit 1
fi
fi
# Try WiFi if USB didn't work
if [ "$INSTALLED" = "false" ] && [ "$FORCE_USB" != "true" ]; then
echo "Connecting to Control Hub via WiFi ($CONTROL_HUB_IP:$CONTROL_HUB_PORT)..."
adb connect "$CONTROL_HUB_IP:$CONTROL_HUB_PORT" 2>&1 | grep -v "cannot connect" || true
sleep 2
if adb devices | grep -q "$CONTROL_HUB_IP"; then
echo "✓ Connected via WiFi"
if adb install -r "$APK_PATH"; then
INSTALLED=true
fi
fi
fi
if [ "$INSTALLED" = "false" ]; then
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " Error: Could Not Connect to Control Hub"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "Connection options:"
echo ""
echo "1. USB (Recommended)"
echo " • Plug Control Hub into computer"
echo " • Run: $0 --usb"
echo ""
echo "2. WiFi Direct"
echo " • Connect to 'FIRST-xxxx-RC' network"
echo " • Run: $0 --wifi"
echo " • Default IP: 192.168.43.1"
echo ""
echo "3. Custom Network"
echo " • Find Control Hub IP on your network"
echo " • Run: $0 -i YOUR_IP"
echo ""
echo "Debug:"
echo " • Check devices: adb devices"
echo " • Test connection: adb connect $CONTROL_HUB_IP:$CONTROL_HUB_PORT"
echo ""
exit 1
fi
echo ""
echo "════════════════════════════════════════════════════════════════"
echo " ✓ Deployment Complete!"
echo "════════════════════════════════════════════════════════════════"
echo ""
echo "On Driver Station:"
echo " 1. Go to OpModes menu"
echo " 2. Select TeleOp → 'Main TeleOp'"
echo " 3. Press INIT, then START"
echo ""
echo "Your code is now running on the robot! 🤖"
echo ""
ENDSCRIPT
chmod +x "$project_dir/deploy-to-robot.sh"
}
# Setup Gradle wrapper
setup_gradle_wrapper() {
local project_dir="$1"
cd "$project_dir"
# Create gradle wrapper properties
mkdir -p gradle/wrapper
cat > gradle/wrapper/gradle-wrapper.properties <<EOF
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
EOF
# Check if gradle is available
if ! command -v gradle &> /dev/null; then
echo "Error: gradle command not found"
echo "Gradle must be installed to generate wrapper scripts"
echo ""
echo "Install:"
echo " Ubuntu/Debian: sudo apt install gradle"
echo " macOS: brew install gradle"
return 1
fi
echo "Generating Gradle wrapper..."
# Try with system gradle first
if gradle wrapper --gradle-version 8.9 --no-daemon 2>/dev/null; then
echo "✓ Gradle wrapper created"
else
echo ""
echo "System Gradle failed. Using fallback method..."
# Download wrapper jar directly
local wrapper_jar_url="https://raw.githubusercontent.com/gradle/gradle/v8.9.0/gradle/wrapper/gradle-wrapper.jar"
if command -v curl &> /dev/null; then
curl -sL "$wrapper_jar_url" -o gradle/wrapper/gradle-wrapper.jar 2>/dev/null
elif command -v wget &> /dev/null; then
wget -q "$wrapper_jar_url" -O gradle/wrapper/gradle-wrapper.jar 2>/dev/null
else
echo "Error: Need curl or wget to download wrapper jar"
return 1
fi
if [ ! -f "gradle/wrapper/gradle-wrapper.jar" ]; then
echo "Error: Failed to download gradle-wrapper.jar"
return 1
fi
# Create proper gradlew script
cat > gradlew <<'GRADLEW_END'
#!/bin/sh
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
APP_BASE_NAME=${0##*/}
# Determine the Java command
if [ -n "$JAVA_HOME" ] ; then
JAVACMD=$JAVA_HOME/bin/java
else
JAVACMD=java
fi
# Check if Java is available
if ! "$JAVACMD" -version > /dev/null 2>&1; then
echo "ERROR: JAVA_HOME is not set and no 'java' command could be found"
exit 1
fi
# Execute Gradle
exec "$JAVACMD" -Xmx64m -Xms64m -Dorg.gradle.appname="$APP_BASE_NAME" -classpath "$(dirname "$0")/gradle/wrapper/gradle-wrapper.jar" org.gradle.wrapper.GradleWrapperMain "$@"
GRADLEW_END
chmod +x gradlew
# Create Windows batch file
cat > gradlew.bat <<'GRADLEWBAT_END'
@if "%DEBUG%" == "" @echo off
setlocal enabledelayedexpansion
set DIRNAME=%~dp0
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
set CLASSPATH=%APP_HOME%gradle\wrapper\gradle-wrapper.jar
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
goto execute
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%\bin\java.exe
:execute
"%JAVA_EXE%" -Xmx64m -Xms64m -Dorg.gradle.appname="%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
GRADLEWBAT_END
echo "✓ Gradle wrapper created (via fallback)"
fi
# Verify wrapper was created
if [ ! -f "gradlew" ]; then
echo "Error: gradlew script not created"
return 1
fi
}
# Check if project is a generator project
is_generator_project() {
local project_dir="$1"
[ -f "$project_dir/.ftc-generator-version" ]
}
# Get project generator version
get_project_generator_version() {
local project_dir="$1"
if [ -f "$project_dir/.ftc-generator-version" ]; then
cat "$project_dir/.ftc-generator-version" | tr -d '\n\r'
else
echo "unknown"
fi
}
# Upgrade project
upgrade_project() {
local project_dir="$1"
local template_dir="$2"
local old_version=$(get_project_generator_version "$project_dir")
echo "Upgrading project from $old_version to ${GENERATOR_VERSION}..."
cd "$project_dir"
copy_template "$template_dir/build.gradle.kts" "build.gradle.kts"
process_template "$template_dir/settings.gradle.kts.template" "settings.gradle.kts"
process_template "$template_dir/gitignore.template" ".gitignore"
copy_template "$template_dir/build.sh" "build.sh"
chmod +x "build.sh"
create_deploy_script "$project_dir"
echo "${GENERATOR_VERSION}" > ".ftc-generator-version"
echo "✓ Upgrade complete"
}
# Initialize git repo
init_git_repo() {
local project_dir="$1"
cd "$project_dir"
if [ ! -d ".git" ]; then
git init > /dev/null 2>&1
git add . > /dev/null 2>&1
git commit -m "Initial commit from FTC Project Generator v${GENERATOR_VERSION}" > /dev/null 2>&1
echo "✓ Git repository initialized"
fi
}
# Check prerequisites
check_prerequisites() {
local missing=()
command -v git &> /dev/null || missing+=("git")
command -v java &> /dev/null || missing+=("java")
command -v gradle &> /dev/null || missing+=("gradle")
if [ "${#missing[@]}" -gt 0 ]; then
echo "Error: Missing tools: ${missing[*]}"
echo "Install: sudo apt install ${missing[*]}"
return 1
fi
echo "✓ All prerequisites satisfied"
return 0
}
# Setup Android SDK automatically
setup_android_sdk() {
local android_sdk_dir="${ANDROID_SDK_DIR:-$HOME/.android-sdk}"
# Check if already configured
if [ -n "$ANDROID_HOME" ] && [ -d "$ANDROID_HOME" ]; then
echo "✓ Android SDK already configured at $ANDROID_HOME"
return 0
fi
if [ -d "$android_sdk_dir" ] && [ -f "$android_sdk_dir/cmdline-tools/latest/bin/sdkmanager" ]; then
echo "✓ Android SDK found at $android_sdk_dir"
export ANDROID_HOME="$android_sdk_dir"
return 0
fi
echo ""
echo ">>> Setting up Android SDK..."
echo "This is needed to build APKs for the Control Hub."
echo "Download size: ~150MB"
echo ""
# Detect OS
local os_type=""
case "$(uname -s)" in
Linux*) os_type="linux" ;;
Darwin*) os_type="mac" ;;
*)
echo "Unsupported OS for auto-setup"
return 1
;;
esac
# Download command-line tools
local tools_url=""
if [ "$os_type" = "linux" ]; then
tools_url="https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip"
else
tools_url="https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip"
fi
echo "Downloading Android SDK command-line tools..."
local temp_zip=$(mktemp -d)/cmdline-tools.zip
if command -v curl &> /dev/null; then
curl -L "$tools_url" -o "$temp_zip" 2>/dev/null || {
echo "Error: Failed to download Android SDK tools"
return 1
}
elif command -v wget &> /dev/null; then
wget -q "$tools_url" -O "$temp_zip" || {
echo "Error: Failed to download Android SDK tools"
return 1
}
else
echo "Error: Need curl or wget to download"
return 1
fi
# Extract
echo "Installing to $android_sdk_dir..."
mkdir -p "$android_sdk_dir/cmdline-tools"
if ! command -v unzip &> /dev/null; then
echo "Error: unzip not found. Install with: sudo apt install unzip"
return 1
fi
unzip -q "$temp_zip" -d "$android_sdk_dir/cmdline-tools"
mv "$android_sdk_dir/cmdline-tools/cmdline-tools" "$android_sdk_dir/cmdline-tools/latest"
rm -rf "$(dirname "$temp_zip")"
export ANDROID_HOME="$android_sdk_dir"
export PATH="$PATH:$ANDROID_HOME/cmdline-tools/latest/bin"
# Accept licenses and install essentials
echo "Installing Android SDK components..."
yes | sdkmanager --licenses > /dev/null 2>&1 || true
sdkmanager "platform-tools" "platforms;android-34" "build-tools;34.0.0" > /dev/null 2>&1
# Add to shell RC files for persistence
local shell_rc=""
if [ -n "$BASH_VERSION" ]; then
shell_rc="$HOME/.bashrc"
elif [ -n "$ZSH_VERSION" ]; then
shell_rc="$HOME/.zshrc"
fi
if [ -n "$shell_rc" ] && [ -f "$shell_rc" ]; then
if ! grep -q "ANDROID_HOME.*android-sdk" "$shell_rc"; then
echo "" >> "$shell_rc"
echo "# Android SDK (added by FTC Project Generator)" >> "$shell_rc"
echo "export ANDROID_HOME=\"$android_sdk_dir\"" >> "$shell_rc"
echo "export PATH=\"\$PATH:\$ANDROID_HOME/cmdline-tools/latest/bin:\$ANDROID_HOME/platform-tools\"" >> "$shell_rc"
echo "Note: Added ANDROID_HOME to $shell_rc"
fi
fi
# Create local.properties in FTC SDK
if [ -n "$FTC_SDK_DIR" ] && [ -d "$FTC_SDK_DIR" ]; then
echo "sdk.dir=$android_sdk_dir" > "$FTC_SDK_DIR/local.properties"
fi
echo "✓ Android SDK configured at $android_sdk_dir"
echo ""
}
Reference in New Issue View Git Blame Copy Permalink