Network Test Suite for Validating Sideload Integrity on Android TV via

Updated 2026-10-29

Why a dedicated test suite matters for Android TV sideloads

Sideloading an APK to Android TV is powerful but slippery. Unlike standard Play Store installs, there is no built-in integrity check, no Play Protect scan on the sideloaded side, and Google’s Remote Configuration often fails to report post-load outcomes. That gap means a broken or tampered install can reach your living-room box without warning, and the symptom is usually discovered only when Netflix, YouTube, or YouTube Music stops streaming over the local network.

A simple connectivity check is not enough. What you need is a deterministic test that reaches the target installation, measures whether the app responds, and confirms the UDP probe path is intact across the home LAN. This article builds that test suite, using pure UDP over the local network. It targets real sideloaded apps like Plex, Jellyfin, Kodi, or any custom media server client that exposes a small TCP/UDP health endpoint.

How the UDP integrity test works

The suite consists of three phases: discovery, liveness, and stream validation.

Phase 1 — Discovery. Broadcast a UDP packet on the local subnet (typically 192.168.x.x) with the payload size set to 64 bytes and a TTL of 64 to force the packet to reach every device. Devices that respond with a valid, non-error message are considered online. On Android TV this is done through a minimal Java component you compile to a shared library and load into your test harness. The broadcast covers the same /24 subnet where your media server lives, so the probe hits the right box.

Phase 2 — Liveness. Send a second packet containing a JSON object:

{"app":"test", "cmd":"ping", "uuid":"%s"}

The targeted app must return a pong response within 200 ms. A missing or error response flags a broken install or a blocked port downstream (for example, a firewall on the TV’s router).

Phase 3 — Stream validation. Open a real UDP stream from the app to your media server’s port (we used Plex’s UDP port 32400 for the test). Measure the sustained bitrate. A healthy installation sustains around 80% of its rated throughput; a sideloaded version that has lost its code signing often drops to near zero after the first minute because of buffering bugs or missing IPC handlers.

The full suite writes results to a timed log on the TV and pushes them via ADB logcat to a laptop. You can then parse the log and plot pass/fail per app version.

Step-by-step setup on Android TV

First, enable developer options and USB debugging. Install the test binary as an unsigned APK. Because sideloading from outside the Play Store is unsupported, use the developer mode toggle to load the test binary from a file path. The binary itself is about 3 MB, well under the typical install limit on most TV distributions.

Next, ensure your media server (Plex, Jellyfin, or MiniDLNA) is reachable on the LAN at 192.168.1.x. The test uses static hostnames in the config file, but the script resolves them via mDNS on the TV side. If mDNS is unavailable, you can hardcode IP addresses in the config JSON.

Run the suite from the TV’s terminal emulator (or ADB shell):

adb shell /data/local/tmp/test_suitestub.bin --config config.json --repeat 5

Each run is 5 iterations of the full 3-phase test. The output includes the UDP broadcast success flag, the ping latency for each tested app, and the sustained stream rate in kbps.

Concrete trade-offs and what you lose

A UDP-based test is fast and unobtrusive. It does not require rooting the TV, and it does not alter the actual installation. However, you must accept several compromises.

• The test binary is unsigned and cannot be distributed officially. You have to build it yourself from a source recipe and sign it with a key you control.
• UDP probes do not verify that app code is intact. They confirm network reachability and app responsiveness, but they cannot detect a modified binary that still responds to ping. For true tamper detection, pair this test with a hash check on the sideloaded OBB or APK.
• The test only checks UDP ports. If your app communicates via HTTPS, you need a separate TLS probe that mirrors the same pass/fail logic. In practice, we recommend adding a HTTPS health check to the suite: a GET on the server’s /health endpoint over TLS, and confirming the response status is 200.

The biggest cost is time. Writing, compiling, and maintaining the test suite takes roughly two hours for a first pass, plus one hour per quarter to update the hosted config and target IPs. But once it exists, a single run test_suitestub.bin --config config.json --repeat 5 replaces an ad-hoc “does Netflix play?” check that takes five minutes and still misses the issue.

Exporting results and automating the pipeline

The suite writes a JSON line per iteration to /data/local/tmp/suitest.log. Each line contains:

• timestamp
• app name
• broadcast result (success/fail)
• ping latency average
• stream throughput (kbps)
• error details

Push it to a laptop with adb logcat -g | grep suitestub, then run a quick Python parser to produce a CSV. Many users already run a small CI job that pulls the log and plots pass rates against the TV’s firmware version. Because Android TV updates strip developer tools, keep the log files on a microSD card or push them over Wi-Fi to a small log collector running on a Raspberry Pi in the same subnet.

If a pass rate drops below 90% across three consecutive runs, treat it as a regression and check the installation logs on the TV. Most sideload failures show up as a missing config file or a crash on startup — both of which the network test surface will flag when the liveness phase times out.

Bottom line for everyday installers

Sideloading apps on Android TV gives you freedom, but it also removes Google’s safety net. Treating the installation like any other software release — with a reproducible, automated network test suite — is the cheapest way to catch a corrupted or malicious payload before you start streaming 4K content.

Build the test stub, point it at your media server, and run it every time you sideload. The one-time investment pays off the moment something breaks. With the UDP probes and a TLS health endpoint, you get continuous visibility into every app that touches the network, all from devices you actually own.

Related reading: more Android TV notes