# A-Team Android ROM Builder

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

Built for Linux, A-Team Android ROM Builder provides an organized graphical interface for managing multiple ROM trees, devices, build configurations, scripts, and remote build machines without relying on lengthy or repetitive terminal commands.

The project remains **script-driven at its core**, allowing existing Bash build workflows to be used while providing a convenient desktop interface around them.

## Features

* Simple GTK 3 Desktop Interface
* Support For Multiple Android ROM Projects
* Support For Multiple Android Devices
* Device-Specific Configuration Files
* Automatic Environment Variable Management
* Embedded VTE Terminal For Live Command & Build Output
* Integrated Resource Monitor For CPU, Memory, & System Usage
* Automated Device Repository Syncing
* Configurable Build Variants & Build Jobs
* Optional Ccache Support
* Script Launcher For Common Development Tasks

## Remote Build / SSH Support

A-Team Android ROM Builder can also work with remote Linux build machines through SSH.

This allows the GUI to remain on your local workstation while commands and Android build operations can be performed on a more powerful remote system.

Remote build functionality includes:

* Configurable SSH Build Hosts
* Connect To Remote Build Machines Directly From The GUI
* Embedded SSH Terminal Sessions
* Remote Command Execution
* Remote Android ROM Build Support
* Remote Resource Monitoring
* Build Host Selection From The GUI
* Reuse Of Existing Device & ROM Configuration
* Local Or Remote Build Workflows From The Same Interface

This makes it possible to use dedicated build servers, secondary Linux machines, or high-core-count systems without having to manually SSH into them before every build.

## Advanced Features

* Modular Python Backend
* Script Launcher For Build & Development Utilities
* Device-Specific Environment Variables
* ROM-Specific Environment Variables
* Automatic Build Environment Generation
* Configurable Android Version
* Configurable Build Variant
* Configurable Parallel Build Jobs
* Ccache Integration
* Local & Remote Build Host Support
* Expandable Device Configuration System
* Expandable ROM Configuration System
* Script Execution From The Selected ROM Tree
* Live Terminal Output
* Integrated System Resource Monitoring

## Project Structure

```text
A-Team-Android_ROM_Builder/
├── builder/        # Core application modules
├── configs/        # Device, ROM, and application configuration files
├── scripts/        # Build, sync, and utility scripts
├── gui.py          # Main GTK application entry point
└── README.md
```

## Requirements

### Base Requirements

* Linux
* Python 3
* GTK 3
* VTE 2.91
* Git
* Bash
* Android Build Dependencies

### Remote Build Requirements

For SSH / remote build functionality:

* OpenSSH Client
* SSH Access To The Remote Linux Build Machine
* Android Build Environment Configured On The Remote Host
* Git / Repo And Required Build Dependencies On The Remote Host

SSH key authentication is recommended so remote build sessions can be started without repeatedly entering passwords.

## Getting Started

Clone the repository:

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

Launch the application:

```bash
python3 gui.py
```

## Configuration

Device settings are stored in:

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

ROM-wide settings are stored in:

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

Configuration files allow device and ROM-specific values to remain separate from the application itself.

When a project is selected, A-Team Android ROM Builder loads the appropriate configuration and automatically exports the required environment variables before executing build or utility scripts.

## Build Workflow

A typical workflow consists of:

1. Launch A-Team Android ROM Builder.
2. Select the Android device.
3. Select the ROM and branch.
4. Select the Android version.
5. Select the local or remote build host.
6. Configure build options such as build variant, jobs, and ccache.
7. Sync the required device repositories.
8. Run build or utility scripts.
9. Monitor terminal output and system resources directly from the GUI.

Because the builder remains script-driven, existing Android build scripts can continue to be used without moving the actual build logic into the GUI.

## Design Philosophy

A-Team Android ROM Builder is intended to act as a frontend and project manager for an existing Android development environment rather than replacing the Android build system.

The application focuses on:

* Reducing repetitive setup tasks
* Keeping device configurations organized
* Keeping ROM configurations organized
* Making switching between Android projects simple
* Simplifying local and remote build workflows
* Providing immediate access to build output
* Providing system resource information during builds
* Keeping build logic inside reusable scripts
* Remaining modular and easy to customize

## Goals

The project aims to provide a lightweight Android ROM development environment that:

* Makes Android ROM development easier to manage
* Reduces repetitive terminal commands
* Provides one interface for multiple devices and ROMs
* Supports both local workstations and remote build servers
* Keeps configuration separate from application logic
* Makes existing Bash scripts easy to integrate
* Remains useful to experienced Android developers without hiding the underlying build process
* Stays easy to customize and extend

## Contributing

Contributions, bug reports, improvements, and feature suggestions are welcome.

Feel free to open an issue or submit a pull request.

## License

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

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

