🔥 ข่าวด่วน: install adb and fastboot drivers on linux mint

Do you need to install ADB drivers on Linux Mint before a phone will show up? No. Linux reaches an Android device through its generic USB stack, so there’s no vendor driver to download the way there is on Windows. To install ADB on Linux Mint, you add the adb and fastboot packages, and whether your user may open the phone’s USB node is decided by a udev rule that ships alongside them.

Original content from computingforgeeks.com - post 82378

This guide installs both tools from the Mint repositories and from Google’s platform-tools zip, shows which copy your shell actually runs, and explains how the shipped udev rules hand out access. There was no phone on the bench. The device was an Android 16 emulator running under KVM on the same VM, so every adb command below ran against a real adbd, while the USB permission path was read from the rules file rather than triggered. The behavior described here was checked in October 2026 on Linux Mint 22.3 against adb 34.0.4 from apt and platform-tools 37.0.1 from Google.

How adb and fastboot reach an Android device on Linux

adb is not one program talking to a phone. It is three pieces, and knowing which piece owns the USB connection explains nearly every problem people blame on missing drivers. When you type an adb command, the request takes this path, in the order the Android adb documentation describes:

The client: the adb command in your terminal. It never touches the device, it only hands the request to the server.
The server: a background adb process listening on tcp:5037. It starts on first use, keeps track of every device, and holds the USB connections open.
The USB node: to talk to a phone the server must open its device file under /dev/bus/usb, and udev decides who can write to that file when the phone is plugged in.
adbd on the device: the daemon on the phone, which only answers once you have accepted the debugging prompt on the screen.

fastboot skips the server and talks to the bootloader directly over USB, but it needs the same write access to the same kind of device node. So the honest answer to “the drivers don’t work” on Mint is almost never a driver. It is either an adb build you did not expect sitting first on your PATH, or a udev rule that did not match your phone’s vendor ID, and the rest of this page is about checking both.

Which adb build should you install on Linux Mint?

Two builds are easy to get on Mint, and they differ in more than age. The Ubuntu archive that Mint 22 sits on packages adb and fastboot from an older Android source tree, while Google publishes a self-contained zip that tracks the current release. This is how the two compared on the lab VM:

What we checked	apt packages (adb, fastboot)	Google platform-tools zip
Version reported	34.0.4-debian	37.0.1-15733141
adb protocol	1.0.41	1.0.41
Where it lands	/usr/lib/android-sdk/platform-tools, linked into /usr/bin	~/platform-tools
Download	1,451 kB across 9 packages	8.7 MB zip
udev rules	Yes, through android-sdk-platform-tools-common	Not on our VM until the apt package was installed
Updates	With the rest of the system	Download the zip again

The version gap looks worse than it behaved. The apt build is three major releases behind, yet both speak the same adb protocol version, and in our test the older client worked against the newer server without complaint. The row that matters more is the udev one, because the rules file that grants USB access came from the apt dependency, not from the zip.

We’d install the apt packages on every Mint machine for that reason, even if you plan to run Google’s binaries. Then add the platform-tools zip in front of them on your PATH when a device’s flashing instructions ask for a recent platform-tools release, since the zip is the only way to get current builds on Mint. Both steps are below, and the apt one comes first.

How to install adb on Linux Mint from the repositories

Start by confirming what the Mint repositories offer, because the package names in older guides no longer exist as packages of their own. This shows the candidate versions for the two tools and the two SDK packages they depend on:

apt-cache policy adb fastboot android-sdk-platform-tools android-sdk-platform-tools-common | grep -E "^[a-z]|Cand"

Every package has a candidate on Mint 22.3, and adb and fastboot share one version, so through apt the two binaries always come from the same build:

adb:
  Candidate: 1:34.0.4-1build3
fastboot:
  Candidate: 1:34.0.4-1build3
android-sdk-platform-tools:
  Candidate: 28.0.2+9
android-sdk-platform-tools-common:
  Candidate: 28.0.2+9

Install the two tools. You do not need to name the common package, because apt pulls it in as a dependency, and that dependency is the one carrying the udev rules:

sudo apt-get update
sudo apt-get install -y adb fastboot

The install took 6 seconds on our VM. The output below is trimmed to the summary and the Setting up lines. Nine packages arrive, covering the two tools, the udev rules package and six small Android libraries that adb and fastboot link against.

0 upgraded, 9 newly installed, 0 to remove and 535 not upgraded.
Need to get 1,451 kB of archives.
After this operation, 4,337 kB of additional disk space will be used.
Setting up android-sdk-platform-tools-common (28.0.2+9) ...
Setting up android-liblog:amd64 (1:34.0.4-1build3) ...
Setting up android-libboringssl:amd64 (14.0.0+r11-4build1) ...
Setting up android-libbase:amd64 (1:34.0.4-1build3) ...
Setting up android-libziparchive:amd64 (1:34.0.4-1build3) ...
Setting up android-libcutils:amd64 (1:34.0.4-1build3) ...
Setting up adb (1:34.0.4-1build3) ...
Setting up android-libsparse:amd64 (1:34.0.4-1build3) ...
Setting up fastboot (1:34.0.4-1build3) ...

Check both tools before plugging anything in, since a version string here proves the binaries run and tells you which build answered:

adb version
fastboot --version

Both report the Debian build, installed under the SDK directory that the packages create. The -debian suffix is how you’ll recognise the apt copy later, once a second adb exists on the system:

Android Debug Bridge version 1.0.41
Version 34.0.4-debian
Installed as /usr/lib/android-sdk/platform-tools/adb
Running on Linux 6.14.0-37-generic (x86_64)
fastboot version 34.0.4-debian
Installed as /usr/lib/android-sdk/platform-tools/fastboot

If adb version prints a version and Installed as points under /usr/lib/android-sdk, the apt install is complete and nothing else needs installing for adb to run. The same steps on Ubuntu and Debian are in our guide to adb and fastboot on Ubuntu and Debian.

What happened to android-tools-adb and android-tools-fastboot?

They survive only as names other packages provide. The old instructions said sudo apt install android-tools-adb android-tools-fastboot, and on Mint 22.3 neither name is a real package any more. We ran this check on the clean VM before installing adb, which is why the simulation still has adb to install:

apt-cache policy android-tools-adb android-tools-fastboot
sudo apt-get install -s android-tools-adb android-tools-fastboot

The policy query shows no candidate for either name, yet the simulated install still resolves the request to the current adb package and its libraries. The excerpt is trimmed to the policy lines and six of the Inst lines:

android-tools-adb:
  Candidate: (none)
android-tools-fastboot:
  Candidate: (none)
Inst android-liblog (1:34.0.4-1build3 Ubuntu:24.04/noble [amd64])
Inst android-libbase (1:34.0.4-1build3 Ubuntu:24.04/noble [amd64])
Inst android-libboringssl (14.0.0+r11-4build1 Ubuntu:24.04/noble [amd64])
Inst android-libcutils (1:34.0.4-1build3 Ubuntu:24.04/noble [amd64])
Inst android-libziparchive (1:34.0.4-1build3 Ubuntu:24.04/noble [amd64])
Inst adb (1:34.0.4-1build3 Ubuntu:24.04/noble [amd64])

So a script that still uses the old names keeps working today, but it relies on a compatibility alias that apt doesn’t promise to keep. Write adb fastboot in anything new.

How to install Google’s platform-tools and put them first on PATH

Google’s zip has no installer. You unpack it and run the binaries from wherever they land. Download the latest Linux build into your home directory and unpack it, which creates ~/platform-tools:

cd ~
curl -sSfLo platform-tools-latest-linux.zip https://dl.google.com/android/repository/platform-tools-latest-linux.zip
unzip -q -o platform-tools-latest-linux.zip

The zip was 8.7 MB when we fetched it, and Google lists what changed in each build in the platform-tools release notes. Call the new adb by its full path to confirm the build, because a bare adb still resolves to the apt copy at this point:

~/platform-tools/adb version

The version line is the one to read. We’ve left off the Installed as line that follows, which points into your home directory:

Android Debug Bridge version 1.0.41
Version 37.0.1-15733141

Now the shell has two adb binaries, and it runs whichever comes first on your PATH. With apt installed, that’s the system copy, which which -a makes visible:

which -a adb

Only the apt paths appear, because ~/platform-tools is not on the PATH yet. The two lines are one file, since /bin is a link to /usr/bin on Mint 22:

/usr/bin/adb
/bin/adb

Put the platform-tools directory in front of the system paths in ~/.bashrc, so every new terminal picks Google’s adb and fastboot first while the apt copies stay installed as a fallback:

echo 'export PATH="$HOME/platform-tools:$PATH"' >> ~/.bashrc

Open a new terminal and check which binaries it now resolves. The current terminal won’t see the change, because bash reads ~/.bashrc only when the shell starts:

which adb fastboot
adb version

On our VM both paths pointed into ~/platform-tools and adb version reported Version 37.0.1-15733141. If you still see /usr/bin/adb, the terminal was opened before the edit, or your shell is not bash and reads a different startup file.

What adb shows when a device is attached

adb lists every device the server can reach, and the state column tells you whether the connection is usable. Since we had no phone, we gave the server something to find: the Android SDK emulator with an Android 16 x86_64 system image, running headless on the same Mint VM with KVM acceleration. It needed the SDK command-line tools and Java 17, and booted in 134 seconds. The sdkmanager we used to fetch it now prints a deprecation notice that points to Google’s newer Android CLI, and if you’d rather manage emulators from a GUI, Android Studio on Linux Mint sets one up for you.

adb devices -l

A healthy entry reads device in the second column. The -l flag adds the product, model and transport ID, and that transport ID is what adb -t takes to pick one device when several are attached:

List of devices attached
emulator-5554          device product:sdk_phone64_x86_64 model:Android_SDK_built_for_x86_64 device:emu64x transport_id:1

Don’t hard-code that transport ID in a script, because the server assigns a new one on every reconnect. After we restarted the emulator it came back as transport_id:2, and adb -t 1 failed with adb: no device with transport id '1'.

A phone over USB shows its serial number in the first column instead of emulator-5554. A state of unauthorized means adbd is waiting for you to accept the prompt on the phone. A permission problem doesn’t hide the phone: adb can still read the USB device without write access, so it lists the serial with no permissions instead, which is the udev case covered at the end of this guide. An empty list usually means USB debugging is off in Developer options or the cable only carries charge. We could only produce the healthy case, because an emulator connects over a local socket and never goes through USB authorization.

We also checked what happens with both builds installed. With Google’s server already running, the apt client at /usr/bin/adb listed the emulator normally and did not restart the server, because both builds use the same protocol version. The terminal below is rendered from the captured outputs of two lab steps, the apt version check and that cross-build check, rather than from one live session:

adb version, fastboot version and adb devices output on Linux Mint 22.3

With the device listed, the everyday commands work the same on an emulator as on a phone. These read the Android release and model straight from the device’s properties:

adb shell getprop ro.build.version.release
adb shell getprop ro.product.model

The emulator answered with its Android version and model string. A phone returns its own model name here, which is a quick way to confirm you’re talking to the device you meant when more than one is plugged in:

16
Android SDK built for x86_64

File transfer is the other job most people want adb for. Push a small file into the device’s Download folder, read it back on the device, then pull it to a new name on Mint so you know the round trip works in both directions:

echo hello-from-mint > /tmp/hello.txt
adb push /tmp/hello.txt /sdcard/Download/
adb shell cat /sdcard/Download/hello.txt
adb pull /sdcard/Download/hello.txt /tmp/hello-back.txt
cat /tmp/hello-back.txt

Each transfer reports one file and zero skipped, and the content survives the trip.

/tmp/hello.txt: 1 file pushed, 0 skipped. 0.1 MB/s (16 bytes in 0.000s)
hello-from-mint
/sdcard/Download/hello.txt: 1 file pulled, 0 skipped. 0.0 MB/s (16 bytes in 0.002s)
hello-from-mint

The transfer rates mean nothing for a 16-byte file, so don’t read speed into them. If you only want Android apps on the desktop rather than a device to debug, Waydroid runs Android in a container and skips adb setup for daily use.

Why adb start-server doesn’t need sudo

The adb server runs fine as your normal user, and starting it with sudo is a habit worth dropping. Older Linux guides, including the earlier version of this one, told you to run sudo adb kill-server and sudo adb start-server whenever devices didn’t appear. That works around a permission problem by running the whole server as root, so every later adb command from your user is served by a root process. Meanwhile the missing udev rule that caused the problem is still missing.

adb kill-server
adb start-server
adb devices

Without sudo the server stops, starts again on port 5037 and finds the device straight away. Nothing in this sequence needed root:

* daemon not running; starting now at tcp:5037
* daemon started successfully
List of devices attached
emulator-5554	device

The restart itself is still useful. After you change a udev rule or plug in a phone that shows as unauthorized, adb kill-server followed by any adb command makes the server rescan with fresh permissions. Just run it as yourself.

What fastboot does when no device is in bootloader mode

fastboot only sees a device that’s already in bootloader mode, and with nothing connected it behaves in two different ways depending on the command. A listing returns at once with no output, while a command that needs a device waits for one indefinitely:

fastboot devices
timeout 5 fastboot getvar product

fastboot devices printed nothing and exited with status 0, which is easy to misread as a broken install. The second command blocked until timeout killed it after 5 seconds, exit code 124:

< waiting for any device >

Neither result says anything is wrong with the install. Both describe an empty bus, and the second one is the message people search for.

fastboot stuck at “< waiting for any device >”

This message means fastboot found no device in bootloader mode that it could open, and it’ll keep waiting until one appears or you press Ctrl+C. The emulator cannot enter a fastboot bootloader, so we saw only the no-device case and did not flash anything. On a real phone, the usual cause is that the phone is still booted into Android, because adb mode is not fastboot mode. Reboot into the bootloader first, with adb reboot bootloader or the phone’s key combination, then run fastboot devices again. A serial number there means the wait is over. A serial followed by no permissions is the udev case below, while an empty list with the phone on its bootloader screen points to the cable or the USB port.

How udev rules cause the adb “no permissions” error

Whether your user can open a phone’s USB node is decided by 51-android.rules, which the apt install placed in /lib/udev/rules.d. It does not grant access per device; it tags known vendors first and then applies one permission rule to everything it tagged. This command shows who owns the file, how many vendors it covers, three of them, and the rule that sets the permissions:

dpkg -S /lib/udev/rules.d/51-android.rules
grep -c "ATTR{idVendor}" /usr/lib/udev/rules.d/51-android.rules
grep -m3 -E "18d1|04e8|2717" /usr/lib/udev/rules.d/51-android.rules
grep -E "GROUP|MODE|TAG" /usr/lib/udev/rules.d/51-android.rules | sort | uniq -c | sort -rn | head -3

The file belongs to android-sdk-platform-tools-common and lists 132 vendor IDs, including Google (18d1), Samsung (04e8) and Xiaomi (2717):

android-sdk-platform-tools-common: /lib/udev/rules.d/51-android.rules
132
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ENV{adb_user}="yes"
SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", ENV{adb_user}="yes"
SUBSYSTEM=="usb", ATTR{idVendor}=="2717", ENV{adb_user}="yes"
      1 ENV{adb_user}=="yes", MODE="0660", GROUP="plugdev", TAG+="uaccess"

Reading the output from the top, the mechanism has three parts:

Vendor lines: each one matches a USB vendor ID and only sets a flag, adb_user=yes. A phone whose vendor is not listed never gets the flag.
The permission rule: any device carrying the flag gets mode 0660 and group plugdev, so members of that group can read and write it.
The uaccess tag: it also gives the user logged in at the local desktop access to the node, whether or not they’re in plugdev.

On our Mint VM the desktop user was already in plugdev, so with the apt package installed the group side was covered before we touched anything. That leaves two ways for a phone to end up unreachable, and current adb names each one in its error text.

no permissions (missing udev rules? user is in the plugdev group)

Current adb builds, including the two tested here, print no permissions (missing udev rules? user is in the plugdev group); see [http://developer.android.com/tools/device.html] next to the serial when you are in plugdev but the device node isn’t writable. On Mint with the apt package installed, the likely cause is that the phone’s vendor ID isn’t among the 132 in the file. When you are not in the group, the message reads no permissions (user <name> is not in the plugdev group); see [...] instead. We could not reproduce either string, because the emulator never goes through USB. The wording comes from adb’s diagnose_usb source, and the fixes below follow the rules file’s own mechanism without having been run against a phone in our lab.

For the second message, add your account to the group with sudo usermod -aG plugdev $LOGNAME, then log out and back in so the new group applies, as Google’s device setup notes describe. We didn’t need it and so didn’t run it, because our user was already a member.

For the first message, find the phone’s vendor ID with lsusb while it’s plugged in. It’s the four hex digits before the colon in the ID column. Then add a local rule that sets the same flag for that vendor. The file name matters here. udev reads rules from /etc/udev/rules.d and /lib/udev/rules.d as one list sorted by name. A file starting with 50 therefore runs before the shipped 51 file, so its flag is already set when the permission rule checks for it.

sudo vim /etc/udev/rules.d/50-android-local.rules

vim is installed on stock Mint 22.3, and nano or the desktop’s xed work just as well if you prefer them. Add one line, with your phone’s ID in place of 1234, which is only an example value:

SUBSYSTEM=="usb", ATTR{idVendor}=="1234", ENV{adb_user}="yes"

Check the syntax before loading it. udev skips a broken rule with only a journal message, so a typo would leave you exactly where you started:

sudo udevadm verify /etc/udev/rules.d/50-android-local.rules

The summary at the end of the output should read one success and no failures, as it did for the example line on our VM:

  Success: 1
  Fail:    0

Reload the rules and replay the USB device events. Both commands returned 0 on our VM. Then unplug the phone and plug it back in so its node is created again under the new rule, and restart the adb server so it rescans:

sudo udevadm control --reload
sudo udevadm trigger --subsystem-match=usb
adb kill-server
adb devices

The phone should now show unauthorized until you accept the debugging prompt on its screen, and device after that. Keep your rule in /etc rather than editing the shipped file, because a package update would overwrite your change in /lib/udev/rules.d. If you work on the Mint machine over SSH instead of at its desktop, the uaccess tag does not apply to that session unless you are also logged in at its desktop. There, plugdev membership is what gives you access, and id -nG shows whether your account has it. That matters most on a box you reach with SSH keys and where nobody is logged in at the seat.