PizzaG/A-Team-Android_ROM_Builder
Watch
1
0
Fork
You've already forked A-Team-Android_ROM_Builder
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

v1.02 Release

Browse source
This commit is contained in:
PizzaG 2026-08-14 05:12:17 -05:00
commit bc1d7ddb35
4 changed files with 2039 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

401
README.md
View file

@ -1,184 +1,337 @@
# 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.
A GTK-based Android ROM development and build environment designed to simplify syncing, configuring, building, 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.
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 project remains **script-driven at its core**, allowing existing Bash build workflows to be used while providing a convenient desktop interface around them.
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
* 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
- 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
## 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
## Project Layout
```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
├── 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 Requirements
### Base
* Linux
* Python 3
* GTK 3
* VTE 2.91
* Git
* Bash
* Android Build Dependencies
- Linux
- Python 3
- GTK 3
- VTE 2.91
- Git
- Bash
- Android ROM build dependencies appropriate for the selected ROM
### Remote Build Requirements
### Optional / Feature-Specific
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.
- `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
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
```
The application expects to be run from the A-Team Android ROM Builder project directory.
## Configuration
Device settings are stored in:
A-Team Android ROM Builder uses simple `KEY=VALUE` configuration files.
### Device Configuration
Device files live in:
```text
configs/<device>.conf
configs/devices/<device>.conf
```
ROM-wide settings are stored in:
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
```
Configuration files allow device and ROM-specific values to remain separate from the application itself.
A selected ROM Source can also contain its own rom.conf, for users who build multiple roms:
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.
```text
<ROM_ROOT>/rom.conf
```
## Build Workflow
When the project is loaded, the ROM-root `rom.conf` takes precedence over the builder's `configs/rom.conf`.
A typical workflow consists of:
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.
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.
**Important:** Linux filenames are case-sensitive. The current loader looks specifically for lowercase `rom.conf`.
Because the builder remains script-driven, existing Android build scripts can continue to be used without moving the actual build logic into the GUI.
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`.
## Design Philosophy
## Build Command Configuration
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.
Known build commands are loaded from:
The application focuses on:
```text
configs/rom_build_commands.conf
```
* 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
Entries can be simple command names:
## Goals
```text
Lineage
Derpfest
```
The project aims to provide a lightweight Android ROM development environment that:
or display-only/default entries using `-->`:
* 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
```text
Default --> Rom.conf
```
## Contributing
The Build tab reads this file when the application starts and populates the build-command dropdown.
Contributions, bug reports, improvements, and feature suggestions are welcome.
The selected command becomes the project's `BUILD_COMMAND` value and is exported to build scripts.
Feel free to open an issue or submit a pull request.
## 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**