# A-Team Android ROM Builder

A GTK-based Android ROM development and build environment designed to simplify syncing, configuring, building, and managing custom Android ROM projects.

A-Team Android ROM Builder is built for Linux and provides a graphical frontend around a **script-driven Android ROM workflow**. The application manages project state, device configuration, ROM configuration, build options, local/remote build hosts, reusable project profiles, build commands, synchronization scripts, tools, terminal access, resource monitoring, and updater operations while leaving the actual ROM build logic in Bash scripts.

The goal is not to hide the Android build system. The goal is to make the repetitive project setup around it easier to manage.

## Features

- GTK 3 desktop interface
- Multiple Android ROM projects
- Multiple Android devices through device configuration files
- Device-specific environment variables
- ROM-specific environment variables
- ROM-local configuration override support
- Local and remote SSH build hosts
- Embedded VTE terminal
- Integrated resource monitor
- Device source synchronization
- Gapps synchronization
- Configurable Android version
- Build variant selection
- Build command selection from `configs/rom_build_commands.conf`
- Configurable build job count
- Ccache option
- Custom APN option
- GApps variant selection
- Clean variant selection
- Installer variant selection
- Reusable Project Profiles
- Desktop launcher creation
- Splash-screen selection
- Desktop launcher icon selection
- Updater with status messages and step-based progress
- Script-driven architecture that keeps build logic outside the GUI

## Project Layout

```text
A-Team-Android_ROM_Builder/
├── builder/                    # Python application/backend modules
├── configs/
│   ├── devices/               # Device configuration files
│   ├── a_team_setup.conf      # A-Team setup variables
│   ├── hosts.conf             # Local/SSH build hosts
│   ├── rom.conf               # Default ROM configuration
│   ├── rom_build_commands.conf # Build command dropdown entries
│   └── upload_services.conf   # Upload-service variables
├── profiles/                  # Saved Project Profiles
├── scripts/
│   ├── devices_sync/          # Device-specific sync scripts
│   ├── build.sh
│   ├── clean.sh
│   ├── sync.sh
│   ├── gapps_sync.sh
│   ├── updater.sh
│   └── other utility scripts
├── gui.py                     # GTK application entry point
└── README.md
```

## Requirements

### Base

- Linux
- Python 3
- GTK 3
- VTE 2.91
- Git
- Bash
- Android ROM build dependencies appropriate for the selected ROM

### Optional / Feature-Specific

- `btop` or `bpytop` for the Resource Monitor
- `git-lfs` for repositories that require Git LFS
- `7z` for setup backups and updater operations
- OpenSSH client for remote build hosts
- SSH access to configured remote Linux systems
- Android build dependencies installed on the remote host when using remote builds

## Getting Started

```bash
git clone https://ateam.gotadell.com/git/PizzaG/A-Team-Android_ROM_Builder.git
cd A-Team-Android_ROM_Builder
python3 gui.py
```

The application expects to be run from the A-Team Android ROM Builder project directory.

## Configuration

A-Team Android ROM Builder uses simple `KEY=VALUE` configuration files.

### Device Configuration

Device files live in:

```text
configs/devices/<device>.conf
```

For example:

```text
configs/devices/milanf.conf
```

A device file defines the identity of the device and the variables required by its scripts.

Example:

```text
DEVICE_CODENAME="milanf"
DEVICE_DISPLAY_CODENAME="Milanf"
DEVICE_DISPLAY_NAME="Moto G Stylus 5G 2022"
DEVICE_KERNEL="5.4"
DEVICE_SOC="sm6375"
DEVICE_MANUFACTURER="Motorola"
DEVICE_MODEL_NUMBER="XT2215"
DEVICE_SYNC_SCRIPT="milanf-sync.sh"
```

See `README-TECHNICAL.md` for the complete process of adding a device.

## ROM Configuration

The builder has a default ROM configuration:

```text
configs/rom.conf
```

A selected ROM Source can also contain its own rom.conf, for users who build multiple roms:

```text
<ROM_ROOT>/rom.conf
```

When the project is loaded, the ROM-root `rom.conf` takes precedence over the builder's `configs/rom.conf`.

This makes it possible to keep ROM-specific settings with the ROM source itself while still providing a global default for projects that do not have their own configuration.

**Important:** Linux filenames are case-sensitive. The current loader looks specifically for lowercase `rom.conf`.

This distinction is useful when the build-command dropdown displays an entry such as `Default --> Rom.conf`: that entry is a human-readable configuration choice, while the actual file used by the loader is `rom.conf`.

## Build Command Configuration

Known build commands are loaded from:

```text
configs/rom_build_commands.conf
```

Entries can be simple command names:

```text
Lineage
Derpfest
```

or display-only/default entries using `-->`:

```text
Default --> Rom.conf
```

The Build tab reads this file when the application starts and populates the build-command dropdown.

The selected command becomes the project's `BUILD_COMMAND` value and is exported to build scripts.

## Build Setup

The Build Setup tab provides:

- Build Host
- Device
- ROM Source
- Android Version
- Build Variant
- GApps Variant
- Clean Variant
- Installer Variant
- Build Jobs
- Ccache
- Custom APN
- Project Profiles

Project Profiles allow a complete set of commonly reused project selections to be saved and loaded without manually rebuilding the configuration every time.

## Sync & Setup Device Source

The Sync & Setup Device Source tab provides:

### Sync & Setup Device

Runs the main synchronization/setup workflow.

The workflow can:

- Verify the selected device configuration
- Set up the A-Team addon package
- Run the device-specific synchronization script
- Perform device-tree-specific setup and patching
- Use the selected project environment

### Sync MindTheGapps Package

The GApps sync script selects the appropriate MindTheGapps branch based on Android version.

The current implementation supports Android 16 and Android 17 mappings defined by the script.

## Build

The Build tab provides a build-command dropdown followed by the Build ROM button.

The build operation receives the current project environment, including:

- Device
- ROM
- ROM branch
- ROM path
- Android version
- Build variant
- Build command
- GApps variant
- Clean variant
- Installer variant
- Build jobs
- Ccache state
- Custom APN state
- Device configuration variables
- ROM configuration variables
- A-Team setup variables
- Upload configuration variables

The actual build remains in `scripts/build.sh`.

## Tools

The Tools tab provides application-development utilities including:

- Splash-screen selection
- Desktop launcher icon selection
- Desktop launcher creation
- ROM cleaning

The launcher and clean buttons use independent width variables so their UI dimensions can be adjusted without changing the underlying functionality.

## Terminal

The embedded terminal uses VTE and launches a Bash shell.

This provides direct access to the selected Linux environment without requiring the user to leave the application.

The terminal is intentionally available because the builder is designed to complement, not replace, normal Android development workflows.

## Resource Monitor

The Resource Monitor tab launches `btop` when available, with `bpytop` as a fallback.

It provides live system information useful during large Android builds.

## Remote Build Hosts

Remote hosts are configured in:

```text
configs/hosts.conf
```

The configuration uses INI-style sections.

Example:

```ini
[Local]
type=local

[BuildServer]
type=ssh
server_address=192.168.1.100
port=22
user=pizzag
remote_rom_source_path=/home/pizzag/Android
ssh_options=
```

Remote hosts can be selected from the Build Setup tab.

SSH options may be used for identity files and other SSH configuration.

## Updater

The updater performs a staged update process:

1. Download update
2. Extract update
3. Back up the current installation
4. Install the update
5. Report successful completion

The updater emits status and progress messages that the GUI uses to update the updater overlay.

## Script-Driven Architecture

The GUI does not contain the Android ROM build system itself.

Instead:

```text
GTK GUI
   |
   v
Project State
   |
   v
Environment Generation
   |
   v
Bash Script
   |
   v
Android ROM Build / Sync / Utility
```

This keeps the application flexible and allows device-specific or ROM-specific logic to remain in scripts where it is easier to maintain.

## License

Released under the **GNU General Public License v3.0 (GPL-3.0)**.

**2019-Present — A-Team Digital Solutions**
