A broken touchscreen does not always mean an Android phone is useless.
If the display is still working and USB debugging is available, you can control the entire phone from your computer using ADB and scrcpy.
This was especially useful for one of my old Honor phones. The touchscreen stopped working, but the phone itself was still perfectly functional.
Instead of replacing the display, I started controlling the phone from my Mac and eventually turned it into a small server.
In this guide, I’ll show you how to do the same.
What We Are Going to Use
We need:
- Android phone
- USB cable
- Mac, Linux, or Windows computer
- ADB
- scrcpy
- USB debugging enabled on the Android phone
The final setup looks like this:
Android Phone
│
│ USB / ADB
│
▼
Computer
│
└── scrcpy
│
▼
Android screen
on your computer
You can then use your mouse and keyboard almost like they are connected directly to the phone.
1. Enable Developer Options
If the touchscreen still works partially, first enable Developer Options.
Open:
Settings → About phone
Find:
Build number
Tap it several times until Android says Developer Options have been enabled.
Then open:
Settings → System → Developer options
Enable:
USB debugging
When you connect the phone to your computer, Android may show:
Allow USB debugging?
Select:
Always allow from this computer
and tap:
Allow
If your touchscreen is completely dead and USB debugging was never enabled before, things become much more difficult because Android intentionally requires user authorization for ADB.
2. Install ADB on macOS
If you are using a Mac with Homebrew:
brew install android-platform-tools
Check that ADB works:
adb version
Now connect the Android phone using USB.
Run:
adb devices
You should see something like:
List of devices attached AFYU9K2402611387 device
If the device says:
unauthorized
look at the Android screen and accept the USB debugging authorization request.
3. Install scrcpy
On macOS:
brew install scrcpy
Check the installation:
scrcpy --version
Now start it:
scrcpy
If everything is working, the Android display should immediately appear in a window on your computer.
You can now use:
Mouse click → Tap Mouse drag → Swipe Keyboard → Type Scroll wheel → Scroll
This effectively gives your phone a replacement touchscreen.
4. Select the USB Device if Multiple ADB Devices Exist
I encountered this after enabling both USB debugging and Wireless Debugging.
Running:
scrcpy
gave:
ERROR: Multiple (2) ADB devices
ADB could see the same phone twice:
USB connection Wireless ADB connection
The easiest solution is to tell scrcpy to use USB:
scrcpy -d
You can also specify the exact serial number:
scrcpy -s AFYU9K2402611387
To see the available devices:
adb devices
If you do not need the wireless ADB connection, disconnect it:
adb disconnect
Then:
scrcpy
should work normally again.
5. Control Android Entirely From the Computer
Once scrcpy opens, you can use the phone almost normally.
For example, I was able to use it to:
Open Android Settings Configure Wi-Fi Configure Tailscale Install apps Change permissions Enable developer settings Manage battery settings Configure VPN Open Termux
This is especially useful if:
Display works + Touchscreen does not work
The phone can remain permanently connected to a computer whenever you need full Android control.
6. Open Apps Using ADB
ADB can also launch Android applications directly.
For example, open Android Settings:
adb shell am start -a android.settings.SETTINGS
You can list installed packages:
adb shell pm list packages
Find a particular package:
adb shell pm list packages | grep tailscale
For example:
package:com.tailscale.ipn
This becomes useful when maintaining a phone remotely.
7. Reboot the Phone Using ADB
Once ADB is connected, you do not need the touchscreen to reboot Android.
Simply run:
adb reboot
The phone will immediately reboot.
This became especially useful for my broken-screen phone because I was configuring it as an unattended server and needed to repeatedly test boot scripts.
You can confirm the phone reconnects with:
adb devices
8. Wireless ADB
Android also supports Wireless Debugging on newer versions.
Open:
Developer options → Wireless debugging
Choose:
Pair device with pairing code
Android will show an IP address, pairing port, and pairing code.
On your computer:
adb pair PHONE_IP:PAIRING_PORT
For example:
adb pair 192.168.1.25:42151
Enter the pairing code.
One important thing to understand is that the pairing port and connection port are different.
Do not assume that the port used by:
adb pair
can also be used with:
adb connect
Wireless Debugging normally creates another connection port after pairing.
9. ADB Pairing Works but Connection Is Refused
This was one of the problems I encountered.
Pairing completed successfully, but:
adb connect IP:PORT
returned:
Connection refused
The main reason was that I was dealing with Android’s dynamically assigned Wireless Debugging ports.
The pairing server and actual ADB connection server are separate.
In our case, Tailscale also complicated discovery because Android sometimes exposed the Tailscale network address rather than the local Wi-Fi address.
Eventually, using USB ADB proved much more reliable.
For a phone that is permanently sitting at home as a server, I prefer:
USB ADB + scrcpy
for administrative access.
10. adb mdns services Shows Nothing
Normally you can try:
adb mdns services
to discover wireless ADB services.
However, in my setup it initially returned nothing.
This can happen depending on the network and VPN configuration.
Since Tailscale was running on the phone, mDNS discovery was not reliable.
If this happens, do not assume ADB itself is broken.
USB debugging is usually the easiest fallback:
adb devices
Then:
scrcpy -d
11. Use scrcpy Over Wireless ADB
If Wireless Debugging is already working, scrcpy can use the TCP/IP ADB device.
If both USB and wireless connections exist:
scrcpy -e
selects the TCP/IP device.
For USB:
scrcpy -d
This makes it easy to switch between:
USB or Wi-Fi
depending on how you are accessing the phone.
For reliability, however, I still prefer USB when working on a phone with a completely dead touchscreen.
12. Keep USB Debugging Available
Some Android manufacturers can aggressively disable debugging or background functionality.
On my Honor phone there were additional Developer Options related to allowing ADB while the phone is charging.
If your phone provides something like:
Allow ADB debugging in charge-only mode
enable it.
Also make sure the computer has already been authorized for ADB.
That way, connecting the USB cable later should give you immediate access:
adb devices
followed by:
scrcpy -d
13. Install Apps Using ADB
You can also install APK files without touching the phone.
For example:
adb install app.apk
To reinstall or update:
adb install -r app.apk
This is very useful on a broken touchscreen device.
You can download an APK on your computer and install it directly through USB.
14. Grant App Permissions Using ADB
Some permissions can also be granted remotely.
For example, I needed camera permission for the Termux:API companion app:
adb shell pm grant com.termux.api android.permission.CAMERA
ADB can therefore become a very powerful maintenance tool when you cannot reliably interact with the touchscreen.
15. Disable Unwanted Apps
ADB can also disable apps you do not need.
For example:
adb shell pm disable-user --user 0 PACKAGE_NAME
To re-enable:
adb shell pm enable PACKAGE_NAME
For an old phone being reused as a server, this allows you to disable unnecessary apps without rooting Android.
Do not blindly disable system packages.
Packages related to Android System, System UI, networking, permissions, Settings, VPN, WebView, and your server applications should be left alone.
16. Useful ADB Commands
Here are some commands I now regularly use with the broken-screen phone.
Check connected devices:
adb devices
Open scrcpy using USB:
scrcpy -d
Reboot:
adb reboot
Open Settings:
adb shell am start -a android.settings.SETTINGS
List packages:
adb shell pm list packages
Install an APK:
adb install app.apk
Disable an app:
adb shell pm disable-user --user 0 PACKAGE_NAME
Enable it again:
adb shell pm enable PACKAGE_NAME
View Android properties:
adb shell getprop
Final Setup
My broken-screen Honor eventually became much more useful than I expected.
The control setup now looks like this:
Honor Android Phone
│
┌────────────┴────────────┐
│ │
Normal use Administration
│ │
Termux USB ADB
│ │
SSH / Samba / Web scrcpy
│
▼
Mac mouse + keyboard
The touchscreen is no longer important.
Most of the time the phone runs unattended.
When I need to change an Android setting, install something, grant a permission, or troubleshoot the phone, I connect the USB cable and run:
scrcpy -d
Within a few seconds, the entire Android interface appears on the Mac.
So before throwing away an Android phone because the touchscreen is broken, check whether the display, USB port, and ADB still work.
With ADB + scrcpy, the phone may still have years of useful life left.