Redmagic 11 Toolbox

A hardware, gaming, cooling, lighting, and automation toolbox built specifically for the RedMagic 11 Pro / NX809J.

Redmagic 11 Toolbox combines cooling, liquid-pump, lighting, native shoulder-trigger touch mapping, per-app performance controls, Magic Key, charging, call-lighting, automation, diagnostics, and portable profiles in one Material-style Android application. The implementation uses interfaces validated on a physical NX809J and does not require the Game Space application to manage native TGK mappings.

Warning

Several hardware controls write directly to kernel and vendor interfaces through root. Stock vendor gaming features use compatibility-gated system APIs where available and fall back only where explicitly implemented. Do not expose NX809J-only hardware controls on another device without porting and validating every interface.

Current platform

Item	Configuration
Application ID	`com.elitedarkkaiser.redmagic`
Version	`2.5.3` (`versionCode 9`)
Development branch	`sixteen`
Minimum Android	Android 9 / API 28
Target and compile SDK	API 35
Language	Kotlin
Java compatibility	Java 17
UI	Material Components
Root	Required for hardware controls; native TGK itself is non-root
Supported device	RedMagic 11 Pro / NX809J

What's new in 2.5.3

Version 2.5.3 completes module-backed shoulder-trigger haptics. When Trigger Bridge 0.3.1 or newer owns a configured game, Toolbox writes the profile's haptics toggle plus the selected Hardware-tab Low, Medium, or High gain and duration to the module. Native TGK remains unchanged and preferred on stock firmware.

The companion module now detects landscape rotation through Android window and display state when the vendor SurfaceOrientation field is absent. This keeps saved L/R targets accurate without a manual property override.

What's new in 2.5.2

Version 2.5.2 adds automatic dual-backend shoulder-trigger mapping and finishes the post-update gameplay lifecycle work. Stock firmware continues to use Native TGK. Compatible NX809J custom ROMs can use the optional Redmagic Trigger Bridge v0.3.0 merged-touch module when the proprietary TGK implementation is absent or rejects configuration.

Native TGK and Trigger Bridge routing

Native TGK remains the first-choice backend on compatible stock firmware.
If the native probe or mapping apply fails, Toolbox releases partial native state and activates an installed Trigger Bridge v0.3.0 or newer.
The module receives the active profile's normalized per-rotation L/R targets and is owned only while the configured application remains in the foreground.
Both backends are disabled during every game-exit, screen-off, editor, configuration-change, and runtime-cleanup path.
Older Trigger Bridge releases are rejected because their separate virtual touchscreen cannot safely coexist with physical gameplay contacts.
A root-only exact validation marker remains available for maintainers to test the fallback on stock hardware without changing the normal native-first path.

Verified merged-touch fallback

Continuous thumbstick movement while tapping or holding either trigger
Both shoulder triggers with one or two physical screen contacts
Repeated finger removal and replacement during trigger activity
Correct saved target coordinates in COD Mobile landscape mode
Stable protocol-B slot ownership without dropped contacts or camera snapping
Two-minute combined-input stress validation on NX809J Android 16

Gameplay update recovery

Foreground hints restart a missing gameplay runtime instead of being ignored.
Stale foreground-monitor authority is retired so overlays do not remain outside the selected application.
APK replacements that change gameplay services, overlays, or trigger routing produce a one-time reboot notice because Android may retain stale service and input state until the next boot.

Version 2.5.3 retains the complete 2.5.1 Game Space-style control surface and runtime recovery stack described below.

Game Space-style in-game controls

A compact toolbox drawer for performance, trigger, cooling, lighting, and utility controls
A movable floating GS button with a dedicated drag grip
A separately movable drawer whose position is saved per application and orientation
A compact movable shoulder-trigger editor with independent floating behavior menus
Smaller L/R target markers that remain draggable during editing
System-gesture inset handling that keeps the button and drawer away from Back gesture edges
No edge-capture handles or full-height gesture interception

Gameplay runtime recovery

A dedicated gameplay foreground service owns overlays and native TGK state instead of the accessibility-service binding
An independent watchdog process keeps a binding to the gameplay runtime and requests reconstruction after unexpected termination
A minimal root-owned service.d supervisor survives firmware-wide application UID kills
Recovery is routed through the Android shell identity and REDMAGIC's one-shot AutoLaunch whitelist before the watchdog foreground service is started
Supervisor installation, replacement, stale-lock cleanup, bounded retry, and log rotation are handled without performing hardware writes
Overlay and trigger state are reconstructed automatically when the configured game is still active

Native shoulder-trigger touch mapping

Independent per-app L and R touch targets using the firmware's native TGK engine
Separate portrait and landscape mappings, named layouts, and in-game re-editing
Persistent, nearly transparent saved targets that remain non-interactive during play
Stock framework press feedback at the mapped targets plus the stock physical-trigger highlights
Per-trigger single-touch, long-press, and rapid-fire behavior with supported counts of 2, 5, or 10
Simultaneous L/R operation without cancelling held touchscreen contacts or thumbstick movement
Foreground-only activation and immediate shutdown when the selected app loses focus
Native TGK diagnostics, profile transfer, and Master Profile backup coverage
No Game Space database dependency and no accessibility gesture, shell-tap, touchscreen sendevent, or virtual-gamepad injection

Per-app stock gaming controls

Compatibility-gated Eco, Balance, and Rise performance modes
Per-app refresh-rate control through the stock REDMAGIC display service
Per-app touch sampling, touch sensitivity, touch-follow, and micro-sensitivity profiles
A foreground-only performance overlay showing refresh rate, touch sampling, active performance mode, FPS, temperature, and fan telemetry
Stock charge-separation control with charger and minimum-battery safety checks
Shared foreground lifecycle coordination so TGK, saved targets, refresh rate, touch tuning, performance mode, and telemetry follow the same selected application

Existing toolbox features

Fan and micropump control, temperature curves, telemetry, and screen-off cooling policy
Fan, logo, and shoulder lighting plus RGB Studio and explicit LED ownership arbitration
Magic Key stock actions, application launching, Android shortcuts, dual-app assignments, and daily schedules
Game Mode, Charging Mode, Call Lighting, Quick Settings tiles, and the launcher cooling widget
Portable, versioned Master Profiles and event-driven automation rules
Shared persistent root execution, duplicate-write suppression, adaptive temperature sampling, and background worker cleanup

Reverse-engineering documentation

The complete native TGK investigation—including firmware classes, Binder transactions, stock database schema, runtime traces, permission testing, activation ordering, visual effects, and the standalone Game Space-independent proof—is documented in docs/NATIVE_TGK_REVERSE_ENGINEERING.md.

Stock Game Space package roles, privileged gesture-monitor behavior, overlay-window evidence, AutoLaunch recovery policy, failed prototypes, and the Toolbox's compatible implementation are documented in the living docs/GAME_SPACE_REVERSE_ENGINEERING.md report. New verified Game Space findings should be added there as the investigation continues.

The sections below document the complete 2.5.3 behavior and current architecture.

Compatibility

The official target is the NX809J running stock RedMagic Android 16 firmware.

LineageOS-based and other custom ROMs can work when they retain the stock RedMagic vendor and kernel interfaces. Compatibility requires equivalent implementations of:

/sys/kernel/fan/*
/proc/driver/micropump/*
/sys/class/leds/aw22xxx_led/*
/sys/class/leds/sar0/*
/sys/class/leds/sar1/*
RedMagic/Nubia Magic Key system settings
Either the REDMAGIC Android 16 IInputManager TGK additions or the optional Redmagic Trigger Bridge v0.3.1 or newer companion module for per-app touch mapping
Stock display, touch-tuning, performance, and charge-separation services for their corresponding per-app features

The app verifies the NX809J identity before requesting root or exposing any controls. The launch gate accepts only exact NX809J model/product identities, including NX809J regional product suffixes, and does not rely on the marketing name alone.

The compatibility layer centralizes the confirmed fan, pump, LED, and trigger paths so capability diagnostics, telemetry, and hardware writes use the same interface definitions. Hardware writes are blocked again at the controller boundary if the device identity is unsupported, protecting against widget, Quick Settings, service, or boot entry points that bypass the activity.

For NX809J custom ROMs, CPU temperature detection resolves the confirmed cpullc-0-0 sensor by thermal-zone type before falling back to known zone numbers. This tolerates framework-level thermal-zone reordering while remaining restricted to NX809J hardware.

Native TGK and the stock per-app gaming controls are exposed only after their specific compatibility probes pass. A custom ROM may retain the fan, pump, LED, trigger, and thermal interfaces while omitting the proprietary framework APIs. Trigger Bridge v0.3.1 or newer can provide merged physical-touch, L/R mapping, automatic rotation, and trigger haptics on an NX809J ROM that retains the confirmed SAR inputs, Synaptics touchscreen, arming nodes, vibrator nodes, and /dev/uinput; stock-only display, touch, performance, and charging controls remain independently gated. Restoring the actual native TGK implementation still requires porting the matching REDMAGIC framework, system-server, native input, vendor, and SELinux pieces rather than copying the application-side Binder calls alone.

Application layout

The application contains five main tabs:

Home
Cooling
Controls
Hardware
Lighting

Home

Live Dashboard

The dashboard displays:

Device model and root status
Current CPU temperature
Fan state, level, and RPM
Pump state, frequency, and speed
Current foreground application
ROM/build fingerprint
CPU and installed RAM

Fan and pump telemetry is collected through a batched root read and cached to reduce shell activity. Dashboard polling pauses when the activity is no longer visible, and a manual refresh remains available.

The Live Dashboard also includes a 30-minute thermal-history graph. It reuses samples already produced by the shared temperature monitor, keeps at most 600 points in memory, and performs no additional sensor reads or storage writes.

Active Mode Inspector

The Home dashboard reports which feature currently owns the shared LED hardware:

Charging Mode
Call Lighting
Game Mode
RGB Studio
Normal saved lighting

It also shows whether cooling is controlled by Game Mode, Auto Fan, Auto Pump, an active call fan pause, or manual saved controls. The last applied Master Profile is shown separately as the base configuration so a temporary higher-priority LED owner is not confused with the profile that supplied the underlying settings.

The inspector uses the app's existing ownership and preference state. It performs no additional root commands, sensor reads, polling loops, or hardware writes. Its priority display follows the real LED arbitration order: Charging, Call Lighting, Game Mode, RGB Studio, then Normal.

Home-screen cooling widget

The optional RedMagic Cooling widget shows the current temperature, fan level, and pump profile. It provides direct Fan, Pump, and Refresh controls, while tapping the widget background opens the full application.

The widget has no scheduled update interval and performs no continuous polling. Hardware is read only when Android creates or updates the widget, when the user requests a refresh, or after a widget control is pressed. Fan and pump root work runs on one background executor rather than the launcher thread.

Quick Settings tiles

Android Quick Settings can expose six optional RedMagic controls:

Cooling Fan
Cooling Pump
Auto Cooling
Shoulder Triggers
RGB Studio
Last applied Master Profile

Each tile reads its state when Android starts listening and refreshes after a press; the tiles do not run a continuous polling loop. Privileged hardware work is dispatched to a shared background executor. Unsupported devices show the tiles as unavailable, and the Shoulder Triggers tile reflects the parsed state of both NX809J trigger nodes.

Diagnostics

The capability scanner reports whether the expected fan, pump, LED, trigger, and slider hardware interfaces are available. Missing interfaces are reported rather than silently treated as working.

Cooling

Fan control

Fan power on/off
Manual levels 0 through 5
Live RPM reading
Fahrenheit or Celsius display
Quiet, Balanced, and Turbo curve presets
Automatic temperature-based fan control

Automatic fan levels are:

Temperature	Level
Below 95°F / 35°C	0
95–103°F / 35–39°C	1
104–112°F / 40–44°C	2
113–121°F / 45–49°C	3
122–130°F / 50–54°C	4
131°F / 55°C and above	5

A 5°F downward hysteresis prevents rapid changes near thresholds. The service does not rewrite the fan level when the desired state already matches the last applied state.

Micropump control

Profile	Frequency	Speed
Slow	4	40
Medium	4	60
Quick	4	80
OC / Experimental	4	90

Automatic pump mode uses Slow below 95°F, Medium from 95°F through 104°F, and Quick at 105°F or higher. The OC profile is manual and intentionally marked experimental.

Screen-off cooling policy

Normal fan and pump activity is blocked while the screen is off unless the device is hot. Cooling remains permitted around 100°F / 38°C or above. Shutdown commands and repeated state writes are deduplicated to reduce root work and battery use.

Controls

The Controls tab provides root verification and RedMagic Magic Key configuration.

Stock Magic Key actions include:

Camera
Game Space
Sound Mode
Flashlight
Voice Recorder
Disabled

The Magic Key can alternatively launch a selected user or system application. It can also use confirmed ZTE mode 17 to launch an Android app shortcut, such as YouTube Search, a new message, or another shortcut published by an installed application.

Shortcut selection uses a two-stage picker: choose the application, then choose one of its manifest, dynamic, or cached Android shortcuts. Shortcut discovery runs through the system shortcut service on a background worker. Stock-action, app-launch, shortcut-launch, and dual-app modes are mutually exclusive.

Dual-app slider

The optional dual-app mode assigns one launchable app to slider-up and another to slider-down. A scheduled pair can replace both default apps during a chosen daily time window, including schedules that cross midnight.

Slider changes are received through the Android setting observer rather than a polling loop. Enabling dual-app mode saves and temporarily replaces the existing Magic Key action; disabling it restores the action and selected application that were active beforehand.

Hardware

Shoulder triggers

The app can enable or disable the trigger hardware, configure automatic startup, and map the left and right triggers independently.

Available mappings include:

None
Volume Up
Volume Down
Play / Pause
Next Track
Previous Track

The Hardware tab presents Trigger Safety as its own card directly below the main Triggers card. Its dedicated configuration dialog reduces accidental input without continuously polling the raw SAR sensors. Four modes are available:

Off — actions run immediately after a valid hardware press
Intent Unlock — requires a configurable tap sequence before actions become active
Hold to Activate — requires an 80, 120, 180, or 250 millisecond hold
Intent Unlock + Hold — combines both protections

Intent Unlock supports separate left and right tap counts plus a 1.5, 2.5, 5, or 10 second unlock timeout. Optional controls can block actions while the keyguard is locked, allow actions only while a selected Game Mode app is active, and let a valid left-trigger press temporarily unlock the right trigger. Input debounce and action cooldown filtering reject duplicate hardware events while preserving held volume-repeat behavior.

Game Mode gating reuses the app's existing event-driven active-game state, so it does not add another foreground-app polling loop.

The Trigger Mapping and Trigger Safety dialogs use the same app-themed Material presentation as the rest of the control center: grouped surface cards, compact selection chips, visible selected states, outlined secondary actions, and accent-colored save actions. Both dialogs follow the selected system light or dark appearance.

Manual Disable Triggers stops the service and hardware without erasing the Auto-start preference. Automatic startup remains paused until the user presses Enable Triggers or restarts the phone.

Game trigger mapping

The Hardware tab exposes a separate per-app trigger-mapping manager. This is not the media-action trigger service described above. On compatible stock Android 16 firmware it programs REDMAGIC's native TGK engine so physical L/R events become screen contacts at user-selected coordinates. On a compatible custom ROM, Trigger Bridge v0.3.1 or newer merges the retained physical touchscreen with the KEY_F7/KEY_F8 trigger contacts through one virtual multitouch device and can provide hardware-vibrator feedback.

Each selected application can store named layouts with independent portrait and landscape targets. The editor launches the selected application, places draggable L/R controls over it, and saves the resulting rectangles. During normal play those targets are shown as nearly transparent, touch-through markers: they cannot steal gameplay input or be dragged until the user deliberately enters edit mode again.

The unified foreground runtime performs the following lifecycle:

Confirm that the selected package is the top-resumed application.
Load the matching orientation and active named layout.
Prefer Native TGK when its state can be read and its mapping can be applied.
If Native TGK is unavailable or rejects the mapping, release its state and activate an installed, compatible Trigger Bridge v0.3.0 or newer; v0.3.1 adds automatic rotation and module haptics.
Keep the unselected backend inactive so the two implementations never own the triggers simultaneously.
Keep the saved markers and optional performance telemetry attached to the same foreground owner.
Disable both backend paths and remove every related overlay immediately when the app loses the foreground, the screen turns off, or the runtime stops.

Single-touch, long-press, and rapid-fire behaviors can be chosen independently for L and R. Rapid-fire counts are restricted to the confirmed stock values. The framework's own top-edge and mapped-target visual effects provide down/up feedback without the app intercepting F7/F8 events.

Native TGK configuration is performed through ordinary app-accessible InputManager calls and does not require root on the tested stock firmware. It remains the preferred backend and retains the complete stock effects and behavior modes. Trigger Bridge v0.3.1 is a root module for NX809J ROMs that preserve the required vendor/kernel trigger, touchscreen, and vibrator interfaces; it is not a generic Android trigger solution. Its daemon boots inactive without a virtual touchscreen, creates the merged proxy only for a configured foreground game, and releases every virtual contact and physical device during cleanup. See the native TGK reverse-engineering report and the companion module's control contract.

Haptic feedback

The Hardware tab contains optional hardware haptic feedback for shoulder-trigger actions, successful dual-app slider launches, and Master Profile application. It is disabled by default and offers Low, Medium, and High strengths with an immediate test pulse when a strength is selected. Trigger Bridge 0.3.1 and newer also use the selected strength for module-backed shoulder-trigger feedback when that game profile enables haptics.

Haptic pulses use the confirmed NX809J zte_vibrator duration, gain, and activate nodes through the shared root broker. Feedback is event-driven, rate-limited, and performs no continuous polling.

Master profiles

Master profiles capture the wider application state, including:

Fan, pump, lighting, and automatic-control state
Game Mode profile and selected games
Per-game profile assignments
Charging Mode profiles
Incoming and connected-call profiles
Call fan-pause preference
RGB Studio configuration
Temperature-unit preference
Magic Key mode and selected application
Magic Key shortcut package, ID, and display label
Dual-app slider mappings and schedule
Hardware haptic enabled state and strength
Real-time preview preference
Trigger mappings, startup state, and complete Trigger Safety configuration
Native TGK applications, named layouts, portrait/landscape targets, per-trigger behavior, rapid-fire counts, haptics, and saved-target visibility
Charge-separation state
Per-app refresh-rate, touch-tuning, and performance-mode profiles

Profiles can be named, applied, deleted, exported as a portable JSON backup, and imported on another installation.

The versioned profile format currently uses schema version 11. Versions 7 through 11 added native TGK profiles, charge separation, refresh-rate profiles, touch-tuning profiles, and performance-mode profiles respectively. Earlier schemas remain importable and receive safe defaults for fields they did not contain. The internal backup-format identifier remains backward compatible across the Redmagic 11 Toolbox rebrand.

Automation rules

Saved Master Profiles can be assigned to power connected, power disconnected, battery low, battery recovered, and first-unlock-after-restart events. Android broadcasts trigger the rules only when those events occur; the automation engine performs no continuous polling. Rules are included in portable JSON backups and are cleared automatically if their assigned profile is deleted.

Settings

The settings page opens from the gear beside the animated Redmagic 11 Toolbox header. It contains app-wide display preferences rather than physical hardware controls:

Fahrenheit or Celsius temperature display
Automatic light/dark appearance following the Android system theme

Physical haptic configuration remains in the Hardware tab.

Lighting

The Lighting tab controls:

Cooling fan LED
Rear logo LED
Shoulder LED strips

Each zone can be enabled, disabled, and configured independently. Effects include Steady, Breathe, Flashing, and Rapid where supported. Colors include Red, Orange, Yellow, Green, Cyan, Blue, Purple, and Pink. Confirmed stock fan-light presets are also supported.

The Real-time preview switch is located inside LED Zones and controls whether changes are written immediately while editing a profile.

RGB Studio

RGB Studio provides a persistent multi-zone color cycle with:

Synchronized or independent LED zones
Selectable ordered color sequence
Steady, Breathe, Flash, and Rapid effects
Per-zone speeds from 0.5 to 6 seconds
Immediate, 1, 5, 15, or 30-minute screen-off timeouts
Apply-to-all action
Explicit service stop control

RGB Studio uses the shared persistent root broker instead of launching su for every animation frame.

Game Mode

Game Mode applies a saved fan, pump, and LED profile when a selected application becomes active. It uses Usage Access and accessibility foreground-app events instead of continuous idle polling.

While a selected game is active, a slow two-minute verification poll checks state. Polling stops when the game closes or the screen turns off, and the normal hardware profile is restored.

Per-app gaming controls

The stock-only per-app controls share the same top-resumed-activity detection used by native TGK. Each controller probes its vendor dependency before exposing or applying a profile:

Refresh rate selects the requested stock display mode for the chosen package.
Touch tuning stores the confirmed REDMAGIC sampling-rate, sensitivity, follow, and micro-sensitivity settings per package.
Performance mode selects Eco, Balance, or Rise and synchronizes the stock audio/performance state when that vendor API is available.
Performance overlay is visible only for opted-in foreground packages and can show display refresh rate, configured touch sampling, performance mode, live FPS when the vendor monitor supplies it, CPU temperature, and cached fan telemetry.

These features are deliberately gated separately. Failure or absence of one vendor API does not disable unrelated NX809J hardware controls or native TGK.

Charge separation

Charge separation uses the stock ZTE provider and charge_separation_switch system state when the compatibility probe succeeds. Enabling is blocked unless a charger is connected and the battery meets the controller's minimum threshold. The saved state is covered by Master Profiles.

Charging Mode

Charging Mode applies dedicated fan, logo, and shoulder LED profiles while power is connected. Android power and battery broadcasts drive the service, so charging state is not continuously polled. The previous valid lighting owner is restored after charging ends.

Call Lighting

Call Lighting supports separate profiles for ringing and connected calls. An optional fan-pause feature saves the previous fan state, stops automatic fan control, turns the fan off during the call, then restores the previous state when the call ends.

LED priority

The ownership system prevents lower-priority modes from overwriting higher-priority lighting:

Charging Mode
Call Lighting
Game Mode
RGB Studio
Normal saved LEDs

When a mode ends, the next valid owner is restored. Normal and Game Mode LED writes are blocked while the screen is off.

Temperature monitoring

Temperature is read from readable Linux thermal zones without opening a root shell. The monitor shares one cached value between the dashboard, Auto Fan, and Auto Pump and reacts immediately to Android thermal-status events.

State	Sampling interval
App visible and interactive	3 seconds
Background and hot	5 seconds
Background, cool, and interactive	15 seconds
Screen off and cool	30 seconds

The worker thread stops when no subscribers remain. The Fahrenheit/Celsius preference is also respected by the shared foreground notification.

Root execution architecture

Normal privileged commands use one serialized persistent root shell. This lowers process churn, preserves command ordering, and shares one broker between cooling, lighting, RGB Studio, and trigger actions.

If the persistent shell fails, it is recreated automatically. A one-shot su -c path remains as a compatibility fallback for root providers that reject interactive shells. Command exit codes are checked.

The two trigger input readers remain dedicated blocking processes because each must continuously consume its kernel input stream.

Hardware write safeguards

Fan levels are clamped to 0–5.
Fan PWM values are clamped to 0–255.
Pump profiles generate known fixed commands.
Stock fan-light presets use an allowlist.
Duplicate writes to the same hardware resource are skipped for two seconds.
Fan and pump telemetry caches are invalidated after successful writes.
Automatic services skip unchanged states.
Root hardware writes are serialized.
Screen-off cooling and LED policies prevent unnecessary hardware activity.

These controls reduce risk and redundant work but cannot eliminate every risk of root-level hardware access.

Foreground services

Auto Fan, Auto Pump, fan-light persistence, and RGB Studio use Android's specialUse foreground-service type. This describes continuous user-enabled internal hardware control and avoids incorrectly consuming Android 15's six-hour dataSync allowance.

Android displays an ongoing notification while continuous hardware services are active.

Boot behavior

After boot or user unlock, the app can restore enabled behavior for:

Trigger auto-start
Charging Mode
Call Lighting
RGB Studio
Dual-app slider handling
First-unlock Master Profile automation

A temporary manual trigger disable is cleared by a full restart.

Permissions

Permission or access	Purpose
Root / superuser	Write fan, pump, LED, trigger, and Magic Key state
Foreground Service	Keep explicitly enabled hardware controls active
Foreground Service Special Use	Correctly classify continuous hardware-control services
Notifications	Display required foreground-service state
Boot Completed	Restore user-enabled services after restart
Usage Access	Detect selected foreground games
Accessibility Service	Receive foreground-app events and support triggers
Phone State	Apply ringing and connected-call lighting
Display-over-other-apps app-op	Support trigger setup where required

Privacy and integrity

The app is designed to operate locally.

The manifest does not request Android's INTERNET permission.
No advertising framework is included.
No analytics SDK is included.
No cloud account is required.
No remote-control service is included.
No device telemetry is uploaded.
Profiles and settings remain in local Android application storage.

GitHub and reference links open in the user's chosen browser. The app itself does not download web content.

The public repository contains the application source, Gradle configuration, and GitHub Actions workflow. Because the app receives root access, users should install trusted builds and review changes before granting permanent superuser permission.

Battery and performance design

Shared persistent root process
Batched root telemetry reads
Thirty-second hardware telemetry cache
Dashboard polling paused outside the foreground
Adaptive non-root temperature monitoring
In-memory thermal history using existing samples
Event-driven charging and phone-state handling
Event-driven Master Profile automation rules
Event-driven dual-app slider launches and scheduled mapping selection
Event-driven, rate-limited hardware haptic feedback
Event-assisted Game Mode activation
Two-minute Game Mode checks only while a selected game is active
Fan, pump, and general write deduplication
Background-priority worker threads
Screen-off cooling and lighting policies
Configurable RGB screen-off timeout
Worker cleanup when services stop

First launch

On first launch, the app validates the device and presents a complete setup checklist before requesting root. It applies the approved feature permissions, verifies every item, scans the hardware interfaces, and then opens the main interface.

The root-assisted setup can grant Usage Access, notification permission, phone-state permission, display-over-other-apps access, and accessibility-service activation. If Android or the root manager rejects an item, the app displays the full five-item status instead of a shortened toast and links directly to the first relevant Android settings page. Review the root request before approving it.

Installation

Open the repository's Releases page.
Download the signed release APK.
Allow installation from the browser or file manager if Android requests it.
Install the APK.
When updating an existing installation, reboot the phone once so Android and REDMAGIC discard the replaced accessibility, overlay, watchdog, and trigger runtime.
Open the application, grant root if requested, and confirm the Toolbox accessibility service remains enabled.

Development artifacts are available from successful Android CI runs.

Building locally

Requirements:

Git
JDK 17
Android SDK Platform 35
Android Build Tools 35.0.0

git clone https://github.com/austineyoung2000/Redmagic-Control-Center.git
cd Redmagic-Control-Center
git checkout sixteen
./gradlew assembleDebug

The debug APK is generated in app/build/outputs/apk/debug/.

Signed release builds use:

SIGNING_STORE_FILE
SIGNING_STORE_PASSWORD
SIGNING_KEY_ALIAS
SIGNING_KEY_PASSWORD

Never commit signing credentials or keystores.

GitHub Actions and releases

Android CI runs for pushes and pull requests involving main or sixteen, manual workflow dispatches, and version tags beginning with v.

The workflow builds and uploads the signed release APK and creates a GitHub Release when a version tag is pushed. Release signing material is supplied through encrypted repository secrets.

Troubleshooting

Root access is missing

Confirm Magisk, KernelSU, APatch, or another compatible su provider is installed.
Verify Redmagic 11 Toolbox is allowed in the root manager.
Remove an existing denied entry and reopen the app if necessary.
Use Controls → Check Root.

Hardware is reported as missing

Confirm the ROM retains the stock RedMagic vendor and kernel interfaces. Use Home diagnostics to identify the unavailable subsystem.

Game Mode does not activate

Grant Usage Access.
Enable the accessibility service.
Select at least one game.
Save a Game Mode profile.
Confirm the screen is on and unlocked.

Triggers do not auto-start

Enable Auto-start triggers.
Confirm the trigger nodes are detected.
Confirm the accessibility service is enabled.
If the APK was just updated, reboot once before testing either native TGK or the companion module.
If manually disabled, press Enable Triggers or restart.

Lighting is replaced unexpectedly

Check whether Charging Mode, Call Lighting, Game Mode, or RGB Studio currently owns the LEDs.

Fan or pump values show `?`

Verify root access and confirm that the expected vendor nodes exist on the current ROM, then refresh the dashboard.

Known limitations

The app is intentionally restricted to NX809J.
Other RedMagic generations require validation and porting.
Vendor paths can change between firmware releases.
Custom ROM support depends on retained stock vendor and kernel interfaces.
Root denial prevents hardware control.
Game Mode requires Usage Access.
Call Lighting requires phone-state access.
Continuous services display an Android notification.
The OC pump profile is experimental.
Profiles are local and are not cloud-synchronized.
Clearing application data removes saved profiles.
Magic Key system settings can remain active until changed again or reset by the ROM.

Reporting issues

Use the repository issue tracker and include:

Device model
ROM and build fingerprint
Android and app versions
Root solution
Steps to reproduce
Relevant Logcat output
Home diagnostics results
Whether the problem occurs on stock firmware

Do not publish phone numbers, account credentials, signing material, or unrelated personal logs.

Contributing

Changes should preserve NX809J device gating, background-thread execution, LED ownership, screen-off safety, write deduplication, local privacy, profile compatibility, and CI build compatibility.

Changes to sysfs, procfs, vendor settings, foreground services, or root execution should be tested on supported physical hardware.

Project links

Disclaimer

This project is independent and is not affiliated with, endorsed by, or maintained by RedMagic, Nubia, or ZTE.

Root access and direct hardware control can cause unexpected behavior, instability, increased heat, battery drain, or hardware stress when used incorrectly. You are responsible for reviewing and testing the software on your device.

Use the application at your own risk.

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
app		app
docs		docs
gradle/wrapper		gradle/wrapper
.gitignore		.gitignore
README.md		README.md
RELEASE_NOTES.md		RELEASE_NOTES.md
build.gradle.kts		build.gradle.kts
gradle.properties		gradle.properties
gradlew		gradlew
gradlew.bat		gradlew.bat
settings.gradle.kts		settings.gradle.kts

Latest commit

History

Folders and files

Repository files navigation