DEV Community: Aristide Bienvenu EMCTHEU

Building Pixel Control Center: High-Performance Android Mirroring on Desktop with Flutter & Scrcpy

Aristide Bienvenu EMCTHEU — Wed, 04 Nov 2026 18:43:30 +0000

If you have ever mirrored an Android handset to your PC or Linux workstation using scrcpy, you know it is the gold standard for low-latency screen casting and remote control.

Yet, running scrcpy on a modern flagship device like the Google Pixel 7 Pro (Tensor G2 SoC, Android 17) inside a real-world multi-network desktop setup quickly reveals four frustrating failure modes:

The "Black Screen with Working Controls" Bug: Invoking --turn-screen-off calls SurfaceControl.setDisplayPowerMode(POWER_MODE_OFF). On Google Tensor hardware, the video encoder buffer blanks out completely—your mouse clicks still work on the phone, but the desktop window renders pure pitch black.
The Ghost Virtual Display Bug: Previous sessions or headless services spawn lingering app_process instances (Display 73, Display 105). Without explicit display binding, scrcpy attaches to an invisible virtual display instead of your active phone screen.
The Dynamic IP / AP Hopping Nightmare: Moving between your home Wi-Fi, office router, or phone hotspot changes your handset's DHCP IP address. Static wireless ADB scripts fail every single time.
The Disappearing Soft Keyboard: Forwarding hardware keyboard inputs via --keyboard=uhid signals Android to hide the on-screen virtual IME, making it impossible to type emojis, passwords in secure fields, or use the dialer.

To solve all four issues with zero configuration, we built and open-sourced Pixel Control Center—migrating from an initial Python prototype to a high-performance Flutter Desktop (Windows & Linux) application.

Here is what we learned, the hardware workarounds that worked, and how we structured the architecture.

1. Taming the Hardware Quirks: Google Tensor & Android 17

Echoing insights from the community on managing ADB wrappers—such as Thoughts on Building a GUI Workflow Around scrcpy and Giving an AI Agent a Real Phone: What ADB Automation Actually Looks Like—handling ADB in production requires accounting for device-specific hardware behavior:

A. The OLED Dimming Workaround (Instead of `POWER_MODE_OFF`)

Rather than cutting display power via --turn-screen-off (which shuts down the hardware encoder pipeline on Tensor G2), our supervisor dynamically reduces backlight brightness to 0 via Android system settings before starting the stream:

// Dim display to 0 to preserve OLED longevity without breaking the encoder buffer:
await adbService.execute([
  ...deviceTargetFlags,
  'shell',
  'settings',
  'put',
  'system',
  'screen_brightness',
  '0',
]);

When the user closes scrcpy, the supervisor catches the process termination and automatically restores normal brightness (100).

B. Forcing Physical Display Binding & Purging Zombie Daemons

To prevent scrcpy from accidentally latching onto ghost virtual displays spawned by Android background processes, our configuration builder always enforces --display-id=0 and kills lingering app_process daemons:

await adbService.execute([...deviceTargetFlags, 'shell', 'pkill', '-9', '-f', 'app_process']);
args.add('--display-id=0');

C. Keeping the On-Screen Keyboard Active & Dismissing Keyguard

To ensure the touch keyboard stays visible even when physical keystrokes are forwarded via Linux UHID, while automatically waking up and unlocking the screen:

await adbService.execute([...deviceTargetFlags, 'shell', 'input', 'keyevent', '224']);
await adbService.execute([...deviceTargetFlags, 'shell', 'wm', 'dismiss-keyguard']);
await adbService.execute([
  ...deviceTargetFlags,
  'shell',
  'settings',
  'put',
  'secure',
  'show_ime_with_hard_keyboard',
  '1',
]);

2. Zero-Config Dynamic Wi-Fi Discovery (4 Tiers)

Instead of forcing users to check their Android settings or type IPs into a terminal, our NetworkDiscoveryService executes a multi-tiered heuristic search:

graph TD
    T1[Tier 1: Check Active Wireless ADB Connections] -->|Not Found| T2[Tier 2: Query USB Device IP via wlan0 / ip route]
    T2 -->|No USB Device| T3[Tier 3: Query ADB mDNS Services Daemon]
    T3 -->|mDNS Unreachable| T4[Tier 4: Multithreaded Subnet Socket Probe Port 5555]
    T4 --> Connected[Auto-Connect TCP/IP Session]

Tier 1 (Active ADB): Checks adb devices -l for existing wireless TCP endpoints, filtering out phantom emulators (like BlueStacks on 127.0.0.1:5555).
Tier 2 (USB Query): If connected by USB, queries ip addr show wlan0 directly.
Tier 3 (mDNS Discovery): Queries Android's native wireless debugging mDNS service (adb mdns services).
Tier 4 (Subnet Socket Probe): Inspects the host machine's local network interfaces (NetworkInterface.list), isolates the /24 subnet prefix (e.g. 192.168.100.x), and asynchronously probes port 5555 across candidate IPs in concurrent batches of 60 with a fast 200 ms socket timeout.

3. High-FPS Performance Optimization & Thermal Protection

On a high-DPI device (1440 × 3120 pixels on the Pixel 7 Pro), raw unconstrained mirroring over Wi-Fi generates massive encoder load, battery heat, and eventual thermal throttling.

By default, Pixel Control Center caps video resolution to 1080p / 1200 px (--max-size=1200) at 8 Mbps:

Drops Tensor G2 video encoder strain by >60%.
Slashes stream latency to sub-30ms.
Prevents extreme thermal throttling on low battery levels.

4. Flutter Desktop Architecture & Atomic Commits

We ported the core logic into clean, layered Dart modules:

AdbService: Process management, device listing parser, and hardware adjustments.
ScrcpyService: Process supervision, stream piping to real-time log consoles, and lifecycle cleanup.
NetworkDiscoveryService: Cross-platform network socket and interface probing.
Material 3 Desktop UI: Responsive dark dashboard with live battery telemetry, quick actions, remote navigation controls, and terminal drawer.

Following atomic git commit discipline ("AND / ET" principle where every commit represents exactly one logical unit of work), the entire history was built across clean, bisectable Conventional Commits:

cb00a85 docs: add initial project readme and hardware notes
cc7620b chore(flutter): scaffold flutter desktop application
7490a10 feat(models): implement device and connection configuration models
d92f8b2 feat(services): implement adb interaction service with pixel quirks support
56f42e7 feat(services): implement scrcpy process supervisor
bb289cd feat(services): implement dynamic local network wifi discovery
dca7037 feat(ui): implement modern material 3 desktop dashboard
9d4ba53 test: add unit tests for adb parsing and device models
045105f fix(launcher): disambiguate adb targets and dismiss keyguard to prevent black screen
d97b61a fix(app): target device flags for adb shell and unlock keyguard
faf8282 fix(services): filter emulators and dismiss keyguard to prevent black screen
2c679e6 perf(app): optimize discovery timeout and target telemetry to prevent lag
b51c1cf perf(launcher): cap stream resolution to 1200 to prevent thermal throttling

5. Open-Source & What's Next

The complete code is open-source and available on GitHub:
👉 github.com/arispacco/pixel-control-center

We are preparing Pixel Control Center for MLH Global Hack Week: Builders Week (November 6–12, 2026), expanding support for automated MSIX packaging for the Windows Store and native Linux AppImage/Flatpak distribution.

If you have encountered black screen issues or thermal throttling on Tensor or Exynos devices when using scrcpy, try these workarounds—and let us know what you think in the comments below!

Why We Rewrote Our Telecom Data Auditor in 100% Native Kotlin (0.99 MB APK, 120 Hz Canvas & Real-Time 4G Telemetry)

Aristide Bienvenu EMCTHEU — Wed, 04 Nov 2026 17:09:41 +0000

When mobile internet users in Cameroon buy a data bundle (Camtel Blue, MTN Mobile Surf, or Orange Good Deal), two questions come up every single day:

Did my phone actually receive the megabytes I paid for, or did the bundle vanish early?
Where in my house does the 4G LTE signal (RSRP / SINR) actually pass through the walls, so I can leave my phone there as a Wi-Fi Hotspot while downloading?

To answer both questions with hardware-level proof, we built CheckMyMega CM — and along the way, we made a radical architectural decision: dropping our 85 MB Flutter shell in favor of a 0.99 MB 100% Native Kotlin APK talking directly to the Android baseband modem, NetworkStatsManager, 120 Hz MEMS sensors, and an on-device/cloud Gemma 4 AI auditor.

Here is the full engineering breakdown of how we built it, why cross-platform bridges failed on real radio hardware, and how we solved it.

1. Why Our Cross-Platform Prototype Failed on Real Hardware

In our initial hybrid build, two critical hardware limitations broke the user experience on a real Google Pixel 7 Pro connected to CAMTEL / Blue (Band 3 FDD 1800 MHz):

Android's 30-second CellInfo Cache: Calling TelephonyManager.getAllCellInfo() across a bridge returned cached RSRP values that stayed frozen at -81 dBm while walking across the living room.
Compass Gimbal Lock & 120 Hz Frame Jitter: Holding the phone upright (pitch > 38°) caused standard Euler angles from SensorManager.getOrientation() to flip wildly. Furthermore, serializing 120 Hz sensor events across inter-process bridges introduced noticeable jitter on smooth OLED screens.
Wi-Fi Socket Pollution: During speed tests, Android routes all traffic through Wi-Fi if available. To measure real SIM throughput without forcing the user to toggle airplane mode or disable Wi-Fi, the socket must bind directly to NetworkCapabilities.TRANSPORT_CELLULAR.

2. Architecture of the 100% Native Kotlin Engine (`0.99 MB` APK)

flowchart LR
    A["4G/5G Baseband Modem\n(TelephonyCallback + requestCellInfoUpdate 750ms)"] --> D["NativeHardwareEngine.kt"]
    B["120 Hz 3D MEMS Sensors\n(RotationVector + Barometer + ZUPT Filter)"] --> D
    C["Linux Kernel Telemetry\n(NetworkStatsManager + content://sms/inbox)"] --> D
    D --> E["120 Hz Hardware Canvas\n(WayfinderCompassRadarView)"]
    D --> F["Per-App UID Auditor\n(WhatsApp, ChatGPT, Hotspot)"]
    D --> G["Gemma 4 AI Engine\n(Google AI Studio / Local Ollama)"]

Bypassing the Modem Cache (`TelephonyCallback` + `requestCellInfoUpdate`)

Starting with Android 10 (API 29) and Android 12 (API 31), getting sub-second RSRP (dBm), SINR (dB), RSRQ (dB), CQI, and Timing Advance updates requires combining TelephonyCallback.SignalStrengthsListener with active requestCellInfoUpdate() calls on a dedicated background executor:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    tm.requestCellInfoUpdate(bgExecutor, object : TelephonyManager.CellInfoCallback() {
        override fun onCellInfo(cellInfo: MutableList<CellInfo>) {
            parseCellInfoList(cellInfo)
            notifyUi()
        }
    })
}

Even when a SIM card has 0 FCFA / no active data bundle, the 4G LTE physical layer stays attached to the cell tower (Reference Signals). This allows our RF Oscilloscope to map indoor wall attenuation room by room (Salon, Près Fenêtre, Chambre, Balcon) with zero synthetic data.

Forced 4G Cellular Sockets (`TRANSPORT_CELLULAR`)

To prevent home Wi-Fi from polluting the SIM measurement, we acquire a dedicated cellular network handle:

val req = NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
    .build()

cm.requestNetwork(req, object : ConnectivityManager.NetworkCallback() {
    override fun onAvailable(network: Network) {
        val conn = network.openConnection(URL("https://speed.cloudflare.com/...")) as HttpURLConnection
        // Real cellular throughput test executed strictly over SIM 4G!
    }
})

3D Tilt-Compensated Wayfinder Compass + Zero-Velocity Update (ZUPT)

Drawing inspiration from Android sensor engineering articles on DEV — such as Master Android Sensors with Jetpack Compose and How I Solved Phantom Pocket Touches on Android — we implemented quaternion coordinate remapping when tilted past 38°, combined with a ZUPT (Zero-Velocity Update) filter that freezes linear acceleration drift whenever the phone is stationary.

3. Real Telecom Auditing via `NetworkStatsManager` & Gemma 4 AI

Instead of synthetic guesswork, CheckMyMega CM audits real usage by cross-referencing:

Carrier SMS messages (content://sms/inbox) for activations and expirations.
Kernel byte counters via NetworkStatsManager.querySummary(ConnectivityManager.TYPE_MOBILE, ...).
Per-app UID consumption (WhatsApp, ChatGPT, YouTube, Wi-Fi Hotspot Tethering) paired with authentic system icons via PackageManager.getApplicationIcon().

Gemma 4 Telemetry Synthesis

The structured telemetry is synthesized by Gemma 4 (supporting gemma-4-27b-it on Google AI Studio, OpenRouter, or local on-device gemma4:e4b via Ollama). The model produces an unvarnished audit comparing the operator's promised megabytes against bytes delivered by the baseband layer:

{
  "isp": "Camtel / Blue",
  "planName": "Surveillance SIM Directe (24h)",
  "osMeasuredDecimalMb": 7.7,
  "topApps": ["Partage de Connexion (4.7 Mo)", "WhatsApp (0.5 Mo)"],
  "bestSpot": "Près Fenêtre (-79 dBm, SINR 8 dB, ~24.5 Mbps)"
}

4. Atomic Git Commits & Single-Responsibility Protocol

We enforced strict atomic commit discipline under the "AND / ET" principle (every commit encapsulates exactly one logical intention). The migration was recorded across 10 clean commits:

c898220 chore(deps): add google_fonts package for UI typography
9e0b4f5 feat(domain): add 4G signal radar models with real SIM telemetry
d0b7655 feat(ui): add signal compass view to Flutter audit dashboard
2de18a5 test(audit): update widget tests for real SIM audit workflow
83a802b chore(android): configure standalone native Kotlin Gradle build
389f95f feat(android-res): replace launcher assets with vector radar icon
debde39 feat(native-models): add multi-SIM, SMS, 4G RF telemetry models
7b89f10 feat(native-engine): add 120Hz sensor engine with Gemma 4 client
2113780 feat(native-views): add 120Hz Canvas compass with vector icon views
fde7920 feat(native-ui): implement native FinTech UI with Gemma 4 settings

5. MLH Global Hack Week: Builders Week & What's Next

We registered CheckMyMega CM as an official project for MLH Global Hack Week: Builders Week (November 6–12, 2026).

The project is now completely independent of heavy frameworks, compiling into a featherweight 0.99 MB native APK with zero external runtime dependencies.

What are your go-to strategies for accurate radio telemetry and sensor fusion on Android? Let us know in the comments below!