No Screen, No Problem: Turning a "Dead" S10 into a Headless Minecraft Server

Lahiru Sandaruwan — Tue, 27 Jan 2026 07:34:04 +0000

The "Paperweight"
I had this decent hardware (Samsung S10 with 8GB RAM) sitting in a drawer doing nothing, just because the display died. I wanted to run a 24/7 Minecraft server without paying monthly fees for a VPS, but I faced a massive "Chicken and Egg" problem: How do you unlock a phone and enable USB Debugging if you can't see the screen?

The "Blind" Heist
For me, the "Ghost Finger" method worked. Blindly typed my password.

Once it unlocked, DeX let me see the screen on my monitor just enough to go into Settings and enable USB Debugging.

Note: If you are stuck on the lock screen and blind typing isn't working for you, check out this Reddit thread for help.

Once debugging was enabled, I could finally connect the phone to my PC and use scrcpy to remove the screen locks and fingerprints.

The Software Stack
I turned the phone into a Linux server,

Termux: The terminal emulator.
Proot-Distro: To run Ubuntu.
The Server: I installed Java and dropped the Minecraft server .jar file in.
Networking: I used playit.gg to tunnel out so my friends could join without me needing to mess with port forwarding.

Cutting the Cord (Going Headless)
The last hack I needed was a way to start the server without ever plugging the phone into a PC again.

The solution was Termux:Boot + sshd.

I installed the Termux:Boot app and created a script at ~/.termux/boot/start-sshd so it runs automatically every time the phone turns on.

#!/data/data/com.termux/files/usr/bin/sh termux-wake-lock sshd

The Result
Now, the workflow is seamless:

Plug the phone into a wall charger.
Wait 60 seconds for it to boot and the script to run.
SSH into it from my PC.

It lives in the drawer permanently. The real pro here is that it uses barely any electricity (unlike a PC) and it's completely free. Plus, it was a great way to learn about ADB.

What ancient hardware do you have sitting in a drawer that deserves a second life?

Interfaces in Java for Loose Coupling

Lahiru Sandaruwan — Wed, 24 Jul 2024 20:02:30 +0000

Why Interfaces, Interfaces are used in Java to achieve loose coupling. which is a design principle whose aim is to reduce the dependencies that exist between many parts of the system.

how interfaces enable loose coupling:

Abstraction: An interface provides a way to define any kind of behavior without defining how it will be implemented. This enables components to communicate with interface without having to know the details of the implementation.
Flexibility: With interfaces, one implementation is replaced by another without any change in the dependent code. This makes a system easier for maintenance.
Modularity: Because interfaces can provide for different components developed and tested independently, they foster modularity. Each component can be developed to conform to the interface, making sure that it can integrate with other components seamlessly.
Dependency Injection: In Spring and similar frameworks, this is used in association with Dependency Injection, which injects the dependencies at runtime. Components are thereby more decoupled, and flexibility of a system is higher when change is required.
Testing: Interfaces let you create unit tests that allow one to mock or stub out the dependencies easily. You can then test each element independently.

Example of Loose Coupling Using Interfaces

public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        // Process payment using credit card
    }
}
public class PayPalPaymentService implements PaymentService {
    @Override
public void processPayment(double amount) {
        // payment processing via PayPal
    }
}
public class OrderService {
    private final PaymentService paymentService;
public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
public void placeOrder(double amount) {
        paymentService.processPayment(amount);
    }
}
// Usage
PaymentService paymentService = new CreditCardPaymentService();
OrderService orderService = new OrderService(paymentService);
orderService.placeOrder(100.0);

as shown by the example, OrderService depends on the interface PaymentService, not on its implementation. This allows you to switch between multiple different ways of implementing payments without having to change the OrderService code.

Forem: Lahiru Sandaruwan

No Screen, No Problem: Turning a "Dead" S10 into a Headless Minecraft Server

Interfaces in Java for Loose Coupling