v1.04 Release

Changelog.txt

@@ -1,2 +1,2 @@
--- Changelog -- v1.02
+-- Changelog -- v1.04
-spread setup check out to remaining devices to stop double patching, rework apn mechanism, expand device source sync to android 17, add a-team setup location variable conf file in configs folder, add a-team addon setup location to project summary screen, add summary screen heading for where the ROM config is loaded from, add project profile selection loading and saving, rework and revise some scripts, add MindTheGapps package sync for roms without a gapps package(downloads based on android version selected), add Tools option to create desktop launcher shortcut, add tools dropdown option with ability to set your dekstop launcher icon, add clean option for no clean, revised ui layout, reworked README.md and added a very detailed README-TECHINCAL.md
+fix update.sh not deleting itself after update, add copy / paste and right click context menu for terminal, tweaked updater output, fixed clean options for build and seperate clean button, rework updater again.

README.md

@@ -1,115 +1,96 @@
 # 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 a Linux desktop application for managing Android ROM development projects through a GTK-based graphical interface.
 
-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 application provides a front end for the repetitive parts of ROM development—project selection, device configuration, ROM configuration, source synchronization, build selection, build execution, tools, terminals, remote hosts, profiles, and updates—while the actual Android operations remain primarily 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
+- GTK 3 desktop GUI
-- Multiple Android ROM projects
+- Build Setup workflow
-- Multiple Android devices through device configuration files
+- Device selection from configuration files
-- Device-specific environment variables
+- ROM source and Android-version selection
-- ROM-specific environment variables
+- Build variant, GApps, clean, installer, ccache, APN, and job-count options
-- ROM-local configuration override support
+- Build command dropdown driven by `configs/rom_build_commands.conf`
-- Local and remote SSH build hosts
+- Project Profiles
-- Embedded VTE terminal
+- Local and SSH build hosts
-- Integrated resource monitor
 - Device source synchronization
-- Gapps synchronization
+- MindTheGapps synchronization
-- Configurable Android version
+- Build execution through the script layer
-- Build variant selection
+- Embedded VTE terminal
-- Build command selection from `configs/rom_build_commands.conf`
+- Terminal copy/paste support
-- Configurable build job count
+- Resource Monitor
-- Ccache option
+- Splash and launcher tools
-- Custom APN option
-- GApps variant selection
-- Clean variant selection
-- Installer variant selection
-- Reusable Project Profiles
 - Desktop launcher creation
-- Splash-screen selection
+- ROM cleaning
-- Desktop launcher icon selection
+- Updater with staged progress/status reporting
-- Updater with status messages and step-based progress
+- Update popup changelog display from the update JSON
-- Script-driven architecture that keeps build logic outside the GUI
+- Cyan, bold updater status text for easier visibility
-
-## 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
+The builder is intended for Linux and requires the Python/GTK stack used by the application plus the tools required by the selected ROM.
+
+Typical requirements include:
 
-- Linux
 - Python 3
 - GTK 3
+- PyGObject (`gi`)
 - VTE 2.91
-- Git
 - Bash
-- Android ROM build dependencies appropriate for the selected ROM
+- Git
+- Android ROM build dependencies
+- `btop` or `bpytop` for the resource monitor
+- Git LFS where required by the selected source
+- OpenSSH client for SSH build hosts
 
-### Optional / Feature-Specific
+## Running the Builder
 
-- `btop` or `bpytop` for the Resource Monitor
+Run the application from its project directory:
-- `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.
+The application expects its configuration, scripts, profiles, and supporting files relative to the builder installation.
 
-## Configuration
+## Configuration Layout
-
-A-Team Android ROM Builder uses simple `KEY=VALUE` configuration files.
-
-### Device Configuration
-
-Device files live in:
 
 ```text
-configs/devices/<device>.conf
+A-Team-Android_ROM_Builder/
+├── builder/
+├── configs/
+│   ├── devices/
+│   ├── a_team_setup.conf
+│   ├── hosts.conf
+│   ├── rom.conf
+│   ├── rom_build_commands.conf
+│   └── upload_services.conf
+├── profiles/
+├── scripts/
+├── gui.py
+├── README.md
+└── README-TECHNICAL.md
 ```
 
-For example:
+## Device Configuration
+
+Devices are discovered from:
 
 ```text
-configs/devices/milanf.conf
+configs/devices/*.conf
 ```
 
-A device file defines the identity of the device and the variables required by its scripts.
+A device normally defines values such as:
+
+```text
+DEVICE_CODENAME
+DEVICE_DISPLAY_CODENAME
+DEVICE_DISPLAY_NAME
+DEVICE_MANUFACTURER
+DEVICE_MODEL_NUMBER
+DEVICE_SYNC_SCRIPT
+```
 
 Example:
 
@@ -117,65 +98,100 @@ Example:
 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.
+The device configuration also provides the variables needed by that device's synchronization and build scripts.
 
-## ROM Configuration
+## ROM Configuration: `rom.conf`
 
-The builder has a default ROM configuration:
+There are two supported locations for ROM configuration.
+
+### Builder default
 
 ```text
 configs/rom.conf
 ```
 
-A selected ROM Source can also contain its own rom.conf, for users who build multiple roms:
+### ROM-local configuration
 
 ```text
 <ROM_ROOT>/rom.conf
 ```
 
-When the project is loaded, the ROM-root `rom.conf` takes precedence over the builder's `configs/rom.conf`.
+The ROM-local file is preferred when it exists. This lets a ROM source tree carry settings specific to that ROM without requiring the builder-wide configuration to be changed.
 
-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.
+Linux filenames are case-sensitive. The loader expects the filename:
 
-**Important:** Linux filenames are case-sensitive. The current loader looks specifically for lowercase `rom.conf`.
+```text
+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`.
+A dropdown entry may be displayed as:
 
-## Build Command Configuration
+```text
+Default --> rom.conf
+```
 
-Known build commands are loaded from:
+but the actual file is still the lowercase `rom.conf`.
+
+Typical ROM configuration values include:
+
+```text
+ROM_BUILD_NAME
+ROM_TARGET_RELEASE
+DEFAULT_ROM_BUILD_COMMAND
+ROM_DISPLAY_NAME
+ROM_VENDOR_NAME
+ROM_MANIFEST
+ROM_BRANCH_PREFIX
+ROM_MAJOR_VERSION
+ROM_MINOR_VERSION
+```
+
+## Build Commands
+
+Build commands are listed in:
 
 ```text
 configs/rom_build_commands.conf
 ```
 
-Entries can be simple command names:
+Example:
 
 ```text
+Default --> rom.conf
 Lineage
 Derpfest
 ```
 
-or display-only/default entries using `-->`:
+The selected command becomes the project's build-command value and is consumed by the build-options script.
+
+The command-selection logic is implemented in:
 
 ```text
-Default --> Rom.conf
+scripts/build_options/rom_build_commands.sh
 ```
 
-The Build tab reads this file when the application starts and populates the build-command dropdown.
+The current function is:
 
-The selected command becomes the project's `BUILD_COMMAND` value and is exported to build scripts.
+```bash
+rom_build_commands()
+```
+
+It supports:
+
+- `lineage`
+- `derpfest`
+- the default command from `rom.conf`
 
 ## Build Setup
 
-The Build Setup tab provides:
+Build Setup combines project configuration into the environment used by the scripts.
+
+The main selections include:
 
 - Build Host
 - Device
@@ -188,150 +204,154 @@ The Build Setup tab provides:
 - Build Jobs
 - Ccache
 - Custom APN
-- Project Profiles
+- Project Profile
 
-Project Profiles allow a complete set of commonly reused project selections to be saved and loaded without manually rebuilding the configuration every time.
+The interface also exposes centralized layout constants for spacing and button widths so the UI can be tuned without changing individual widget construction.
 
 ## Sync & Setup Device Source
 
-The Sync & Setup Device Source tab provides:
+The synchronization workflow is script-driven.
 
-### Sync & Setup Device
+The common entry point is:
 
-Runs the main synchronization/setup workflow.
+```text
+scripts/sync.sh
+```
 
-The workflow can:
+Device-specific synchronization scripts are stored under:
 
-- Verify the selected device configuration
+```text
-- Set up the A-Team addon package
+scripts/devices_sync/
-- Run the device-specific synchronization script
+```
-- Perform device-tree-specific setup and patching
-- Use the selected project environment
 
-### Sync MindTheGapps Package
+The device configuration selects the appropriate script with:
 
-The GApps sync script selects the appropriate MindTheGapps branch based on Android version.
+```text
+DEVICE_SYNC_SCRIPT
+```
 
-The current implementation supports Android 16 and Android 17 mappings defined by the script.
+This keeps device-specific setup out of the main GUI.
+
+## MindTheGapps
+
+GApps synchronization is handled by:
+
+```text
+scripts/gapps_sync.sh
+```
+
+The script selects the appropriate source branch based on the configured Android version and places the resulting GApps source under the ROM tree's expected vendor location.
 
 ## Build
 
-The Build tab provides a build-command dropdown followed by the Build ROM button.
+The Build tab uses the selected build command and project environment to invoke:
 
-The build operation receives the current project environment, including:
+```text
+scripts/build.sh
+```
 
-- Device
+The build script sources the ROM build-command function:
-- 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`.
+```bash
+source "$BUILD_OPTIONS_DIR/rom_build_commands.sh"
+rom_build_commands
+```
 
-## Tools
+This is important because `LUNCH_COMMAND` and `ROM_BUILD_COMMAND` must remain available to the calling build shell.
 
-The Tools tab provides application-development utilities including:
+The selected commands ultimately produce values such as:
 
-- Splash-screen selection
+```text
-- Desktop launcher icon selection
+LUNCH_COMMAND
-- Desktop launcher creation
+ROM_BUILD_COMMAND
-- ROM cleaning
+```
 
-The launcher and clean buttons use independent width variables so their UI dimensions can be adjusted without changing the underlying functionality.
+which the build script executes.
 
 ## Terminal
 
-The embedded terminal uses VTE and launches a Bash shell.
+The application includes an embedded VTE terminal.
 
-This provides direct access to the selected Linux environment without requiring the user to leave the application.
+The terminal accepts normal shell input and now supports copying terminal output out to the desktop clipboard as well as pasting clipboard content into the terminal.
 
-The terminal is intentionally available because the builder is designed to complement, not replace, normal Android development workflows.
+The terminal is intended to remain a normal interactive shell, so regular terminal keyboard behavior is preserved.
 
 ## Resource Monitor
 
-The Resource Monitor tab launches `btop` when available, with `bpytop` as a fallback.
+The Resource Monitor uses `btop` when available and falls back to `bpytop`.
 
-It provides live system information useful during large Android builds.
+It is useful during Android builds for watching CPU, memory, storage, and other system resources.
 
-## Remote Build Hosts
+## Tools
 
-Remote hosts are configured in:
+The Tools area provides utility functions such as:
+
+- Splash selection
+- Launcher icon selection
+- Desktop launcher creation
+- ROM cleaning
+
+## Project Profiles
+
+Profiles store reusable project selections so recurring device/ROM builds do not need to be configured manually every time.
+
+Profiles are stored under:
+
+```text
+profiles/
+```
+
+A profile represents project selections; device and ROM configuration files remain the authoritative source for device- and ROM-specific variables.
+
+## Build Hosts
+
+Hosts are configured in:
 
 ```text
 configs/hosts.conf
 ```
 
-The configuration uses INI-style sections.
+The builder supports local execution and SSH-based remote hosts.
 
-Example:
+A remote host must already have the Android build environment and source prerequisites required by the selected ROM.
-
-```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:
+The updater is divided between the Python updater implementation, the GTK updater UI, and:
-
-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
+scripts/updater.sh
-   |
-   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.
+The shell updater reports staged progress using:
+
+```text
+::PROGRESS::<current>::<total>
+::STATUS::<message>
+```
+
+The GUI converts those messages into the updater progress display.
+
+The update dialog also reads:
+
+```json
+"changelog": "..."
+```
+
+from the update JSON and displays it with the available and installed versions.
+
+Updater status text is displayed **cyan and bold** for improved visibility.
+
+## Development
+
+For architecture, configuration formats, device addition, build flow, updater protocol, terminal implementation, and extension guidance, see:
+
+```text
+README-TECHNICAL.md
+```
 
 ## License
 
-Released under the **GNU General Public License v3.0 (GPL-3.0)**.
+GNU General Public License v3.0 (GPL-3.0).
 
 **2019-Present — A-Team Digital Solutions**

Updates/version.json

@@ -1,6 +1,6 @@
 {
-    "version": "12",
+    "version": "13",
-    "display": "1.02",
+    "display": "1.04",
     "file": "A-Team-Android_ROM_Builder-v1.02.7z",
-    "changelog": "spread setup check out to remaining devices to stop double patching, rework apn mechanism, expand device source sync to android 17, add a-team setup location variable conf file in configs folder, add a-team addon setup location to project summary screen, add summary screen heading for where the ROM config is loaded from, add project profile selection loading and saving, rework and revise some scripts, add Gapps package sync for roms without a gapps package(downloads based on android version selected), add Tools option to create desktop launcher shortcut, add tools dropdown option with ability to set your dekstop launcher icon, add clean option for no clean, revised ui layout, reworked README.md and added a very detailed README-TECHINCAL.md, fix updater status bar"
+    "changelog": "fix update.sh not deleting itself after update, add copy / paste and right click context menu for terminal, tweaked updater output, fixed clean options for build and seperate clean button, rework updater again."
 }