campaign_connector/docs/development/android-dev-setup.md

Android Remote Development Setup Guide

SSH + Termux + VS Code Integration for SMS Campaign Manager

Overview

This guide will help you set up a secure remote development environment on your S24 Ultra using Termux, allowing you to develop your SMS Campaign Manager remotely using VS Code from your Ubuntu homelab over your local network.

Key Benefits:

• Secure Connection: SSH provides encrypted remote access
• Remote Development: Full VS Code functionality via SSH
• Lightweight: Optimized for Android battery and performance
• Simple Setup: No complex networking requirements

Project Structure Reference: See ../PROJECT_STRUCTURE.md for the complete file organization.

---

Part 1: Android Setup (Termux Environment)

Step 1.1: Install Required Applications

1. Install Termux and Termux:API from F-Droid (NOT Google Play Store)

   # Download from F-Droid for security and functionality
   # https://f-droid.org/packages/com.termux/
   # https://f-droid.org/packages/com.termux.api/
   

2. Grant Permissions

   • Open Android Settings → Apps → Termux:API
   • Grant all requested permissions (SMS, Location, Camera, etc.)

Step 1.2: Initial Termux Configuration

# Update packages
pkg update && pkg upgrade -y

# Install essential packages
pkg install -y \
    python \
    python-pip \
    openssh \
    git \
    curl \
    wget \
    nano \
    htop \
    tree \
    file \
    termux-api

# Install development tools
pkg install -y \
    nodejs \
    build-essential \
    clang

# Create directories
mkdir -p ~/.ssh ~/projects ~/bin

Step 1.3: SSH Server Setup in Termux

# Generate SSH keys if not exist
if [ ! -f ~/.ssh/id_rsa ]; then
    ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
fi

# Set password for SSH access
passwd

# Create SSH config
mkdir -p ~/.ssh
chmod 700 ~/.ssh

# Configure SSH server
cat > $PREFIX/etc/ssh/sshd_config << 'EOF'
# Termux SSH Configuration
Port 8022
PasswordAuthentication yes
PubkeyAuthentication yes
PrintMotd yes
Subsystem sftp $PREFIX/libexec/sftp-server
EOF

# Start SSH server
sshd

# Check SSH server status
ps aux | grep sshd

Step 1.4: Get Your Phone's IP Address

# Get your phone's local IP address (Termux-compatible methods)
# Method 1:
ifconfig 2>/dev/null | grep -A1 wlan0 | grep inet | awk '{print $2}' | cut -d: -f2

# Method 2 (if Method 1 doesn't work):
ifconfig wlan0 2>/dev/null | grep 'inet addr' | cut -d: -f2 | awk '{print $1}'

# Method 3 (alternative):
ip addr show wlan0 2>/dev/null | grep 'inet ' | awk '{print $2}' | cut -d/ -f1

# Your SSH connection string will be:
PHONE_IP=$(ifconfig 2>/dev/null | grep -A1 wlan0 | grep inet | awk '{print $2}' | cut -d: -f2)
echo "SSH Connection: ssh -p 8022 $(whoami)@$PHONE_IP"

---

Part 2: Ubuntu Homelab Setup

Step 2.1: Configure SSH Client on Ubuntu

```bash
# Add your phone to SSH config on your Ubuntu machine
cat >> ~/.ssh/config << EOF
Host android-dev
    HostName 10.0.0.193
    User u0_a502
    Port 8022
    ServerAliveInterval 60
    ServerAliveCountMax 3
EOF

### Step 2.2: Test SSH Connection

```bash
# Test the connection from Ubuntu
ssh android-dev

# Or directly:
ssh -p 8022 u0_a502@YOUR_PHONE_LOCAL_IP

Step 2.3: Set up SSH Key Authentication (Optional but Recommended)

On your Ubuntu machine:

# Generate SSH key if you don't have one
if [ ! -f ~/.ssh/id_rsa ]; then
    ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
fi

# Copy your public key
cat ~/.ssh/id_rsa.pub

On your phone (in Termux):

# Add the Ubuntu public key to authorized_keys
echo "YOUR_UBUNTU_PUBLIC_KEY_HERE" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

# Test the key-based authentication
exit  # Exit SSH session and reconnect to test

---

Part 3: Development Environment Options

For minimal resource usage:

Install lightweight development tools:

# Install micro editor (lightweight alternative to VS Code)
pkg install micro

# Install development tools
pkg install git python-pip nodejs

# Clone your project
cd ~/projects
git clone YOUR_SMS_CAMPAIGN_REPO
cd sms-campaign-manager

# Install Python dependencies
pip install -r requirements.txt

# Create development script
cat > ~/bin/dev-setup.sh << 'EOF'
#!/bin/bash
cd ~/projects/sms-campaign-manager
export FLASK_ENV=development
export PHONE_IP="10.0.0.193"
echo "Development environment ready"
echo "Edit with: micro app.py"
echo "Run with: python app.py"
EOF

chmod +x ~/bin/dev-setup.sh

---

Part 4: Project Integration

Step 4.1: Clone Your SMS Campaign Manager

cd ~/projects
git clone /path/to/your/sms-campaign-manager.git
cd sms-campaign-manager

# Install Python dependencies
pip install flask werkzeug

# Test basic functionality
python -c "import flask; print('Flask working')"

Step 4.2: Create Development Environment

# Create development configuration
cat > ~/projects/sms-campaign-manager/.env.termux << 'EOF'
# Termux Development Configuration
PHONE_IP=localhost
ADB_PORT=5555
FLASK_ENV=development
SECRET_KEY=dev-key-for-testing
DEFAULT_DELAY_SECONDS=3
EOF

# Create startup script for development
cat > ~/projects/sms-campaign-manager/start-dev.sh << 'EOF'
#!/bin/bash
# Development startup script
cd "$(dirname "$0")"
source .env.termux
export FLASK_APP=app.py
export FLASK_ENV=development
python app.py
EOF

chmod +x ~/projects/sms-campaign-manager/start-dev.sh

Step 4.3: Termux API Integration Test

3. **Test Termux API functionality:**
   ```bash
   # Check if Termux API is working
   termux-battery-status
   termux-notification --title "Development Setup" --content "SSH connection successful!"

---

## Part 5: Automation and Persistence

### Step 5.1: Auto-start Scripts

Create boot startup script:
```bash
cat > ~/bin/startup.sh << 'EOF'
#!/bin/bash
# Termux startup script

# Start SSH server
sshd

# Get local IP (Termux-compatible)
LOCAL_IP=$(ifconfig 2>/dev/null | grep -A1 wlan0 | grep inet | awk '{print $2}' | cut -d: -f2)

echo "Termux development environment ready!"
echo "Local IP: $LOCAL_IP"
echo "SSH: ssh -p 8022 $(whoami)@$LOCAL_IP"
EOF

chmod +x ~/bin/startup.sh

Step 5.2: Termux Boot Configuration

# Install termux-boot for auto-start
pkg install termux-boot

# Create boot script
mkdir -p ~/.termux/boot
cat > ~/.termux/boot/startup << 'EOF'
#!/data/data/com.termux/files/usr/bin/bash
# Auto-start script
sleep 10  # Wait for system to settle
~/bin/startup.sh
EOF

chmod +x ~/.termux/boot/startup

---

Part 6: Security and Optimization

Step 6.1: Security Configuration

# Configure SSH key authentication
cat > ~/.ssh/authorized_keys << 'EOF'
# Add your Ubuntu machine's public key here
# Copy from ~/.ssh/id_rsa.pub on your Ubuntu machine
EOF

chmod 600 ~/.ssh/authorized_keys

# Disable password authentication after key setup
sed -i 's/PasswordAuthentication yes/PasswordAuthentication no/' $PREFIX/etc/ssh/sshd_config

# Restart SSH with new config
pkill sshd && sshd

Step 6.2: Battery Optimization

# Create power-aware development script
cat > ~/bin/battery-aware-dev.sh << 'EOF'
#!/bin/bash
# Battery-aware development environment

BATTERY_LEVEL=$(termux-battery-status | grep percentage | cut -d':' -f2 | tr -d ' ,%')

if [ "$BATTERY_LEVEL" -lt 20 ]; then
    echo "Low battery ($BATTERY_LEVEL%). Enabling power saving mode."
    # Reduce background processes
    export FLASK_DEBUG=false
    export MINIMAL_MODE=true
else
    echo "Battery OK ($BATTERY_LEVEL%). Full development mode."
    export FLASK_DEBUG=true
    export MINIMAL_MODE=false
fi

# Start development environment
~/projects/sms-campaign-manager/start-dev.sh
EOF

chmod +x ~/bin/battery-aware-dev.sh

---

Part 7: Usage Instructions

Daily Workflow

1. Start Termux Development Environment

   ~/bin/startup.sh
   

2. From Ubuntu - Connect via VS Code

   # Open VS Code and connect to android-dev host
   code --folder vscode-remote://ssh-remote+android-dev/home/projects/sms-campaign-manager
   

3. Or use code-server in browser

   http://YOUR_PHONE_TAILSCALE_IP:8080
   

Troubleshooting Commands

# Check SSH server status
ps aux | grep sshd

# Restart SSH server
pkill sshd && sshd

# Check your phone's current IP (multiple methods)
ifconfig 2>/dev/null | grep -A1 wlan0 | grep inet | awk '{print $2}' | cut -d: -f2
ifconfig wlan0 2>/dev/null | grep 'inet addr' | cut -d: -f2 | awk '{print $1}'
ip addr show wlan0 2>/dev/null | grep 'inet ' | awk '{print $2}' | cut -d/ -f1

# Test SSH connection locally on phone
ssh -p 8022 localhost

# Check running services
ps aux | grep -E "(sshd|code-server)"

---

Part 8: Integration with Your Existing Project

Modify your workplan.md

Update Phase 2 tasks in your workplan:

• Install Termux and Termux:API
• Configure SSH networking over local network
• Set up SSH server and VS Code remote development
• Test Termux API commands for SMS integration
• Create lightweight Flask API server in Termux
• Implement dual connection support (ADB + Termux API)

This setup gives you a professional remote development environment that's lightweight, secure, and perfectly suited for your Android-homelab integration project!

---

Security Notes

• All connections are encrypted through SSH
• Connections work over your local network only
• SSH key authentication recommended over passwords
• Termux API permissions limited to necessary functions
• Battery optimization prevents excessive drain

This configuration provides the foundation for implementing your Android-to-homelab integration concept while maintaining security and simplicity.