Repurposing an Old Tablet: A Time Hole of SDKs, Bootloops, and Stubborn Curiosity
What started as a small idea — turning an old Samsung Galaxy Tab 4 (SM-T230NU) into a dedicated FluidNC pendant — turned into a full dive into Android development, debugging, firmware archaeology, and system recovery.
Here’s the real takeaway from today.
Coming Up With a Simple Goal
The original goal wasn’t complicated:
- Old tablet
- FluidNC web interface
- Fullscreen
- Landscape
- Launch on boot
A normal person would’ve added the webpage to the home screen in Chrome and been done with it - and I might regret not stopping there - but it all came from curiosty.
Learning the SDK Environment
I spent time in Android Studio learning:
- How project structure is laid out
- Where manifests, layouts, Kotlin files, and themes actually live
- How Gradle build files fit together
- How SDK versions impact compatibility
I went from not knowing where things were to being able to navigate the project tree quickly and edit the right files without guessing.
I built a working APK — even if the target browser engine didn’t support what FluidNC needed, the app did exactly what I wrote it to do.
Using ADB and PowerShell
I pushed deeper into device-level interaction:
- Installed platform-tools
- Added ADB to system PATH
- Queried the device
- Verified connection in developer mode
- Used ADB to sideload, inspect, and test
Following the Rabbit Hole Further
Once it became obvious that Android 4.4 was the real limitation, not the app, I kept going.
That led me into:
- Hunting down discontinued libraries (Crosswalk, old .aar packages)
- Trying different browser runtimes
- Experimenting with launching Chrome in kiosk-like modes
- Testing fullscreen flags and orientation locks
- Dealing with missing APIs and deprecated functions
It stopped being about FluidNC at that point.
It became about a carefree environment for testing Android development that sparked from a simple project.
Stepping Into Firmware Territory
When software limits hit a wall, I decided to try upgrading the tablet entirely — aiming for LineageOS or anything newer than KitKat.
That started a different rabbit hole:
- Searching for factory firmware for a device long out of support
- Sorting through mismatched builds and dead download links
- Learning how PIT files map partitions
- Understanding (or trying to) why Odin fails during writes
- Flashing TWRP
- Watching the tablet "soft-brick" into recovery loops
- Figuring out how Samsung’s download mode actually behaves
- Attempting to restore system partitions manually
A lot of it was trial and error.
A lot of it was frustrating.
None of it was wasted.
It was about chasing a small idea until it forced me to learn:
- Android app fundamentals
- Legacy WebView limitations
- How Chrome vs system web engines differ
- ADB usage
- Firmware flashing and partition mapping
- Bootloader interactions
- How older hardware complicates everything
And honestly — it was interesting the whole way through.
Even if the tablet fought back at every step, I walked away knowing a lot more than when I started.
Comments
Post a Comment