We have thousands of devices that we test on hundreds of Ubuntu hosts and one of the big problems we're running into is that unless you log into the host via the GUI, some of the devices don't show up. I was speaking with a coworker and he was saying this was due to the device being unable to mount until an active GNOME session was started, but he didn't know how to fix it - does anyone know a way around this? This is a huge problem for us because if we need to reboot a host (or many hosts), we need to remote into each one, log in, and then the devices show up - logging in via Putty doesn't have any effect - it's only if you log into the GUI that the devices show up.
Our systems are running Ubuntu 16.04.
sudo adb kill-server
sudo adb devices
Has been tried, and does not help.
Thanks!
Create this file as root if it's not created already:
touch /etc/udev/rules.d/51-android.rules
Use this format to add each vendor id from your devices to the file:
SUBSYSTEM=="usb", ATTR{idVendor}=="12d1", MODE="0666", GROUP="plugdev"
In this example, the vendor ID is for my HUAWEI device. The MODE assignment specifies read/write permissions so when you have created/updated the file, execute.
Make the file executable:
chmod +x /etc/udev/rules.d/51-android.rules
Now try restart adb again.
adb kill-server; adb start-server; adb devices -l
If you do not know your vendor ID i have created a list for the most known brands for you, otherwise the vendor ID can be found by lsusb command if you got this package installed, the bolded text is your Vendor ID if the phone is listed.
List devices Vendor ID via lsusb:
lsusb
Bus 002 Device 019: ID 12d1 :107e Huawei Technologies Co., Ltd.
List Vendor ID's for different phone models via curl:
curl -L https://nr1.nu/xm89
SUBSYSTEM=="usb", ATTR{idVendor}=="0502", MODE="0666", GROUP="plugdev" #Acer
SUBSYSTEM=="usb", ATTR{idVendor}=="0b05", MODE="0666", GROUP="plugdev" #ASUS
I assume you know that the phone is connected properly already but if you are not sure about this type dmesg -w followed by connecting the device to your pc again, you should see a message that a new device has been found if everything is okey.
Try this
adb kill-server
adb devices
adb server will be restarted hence there is a change to detect the connected devices
I am using a Samsung galaxy nexus phone (Android 4.0 platform) .
I am developing Android app on Ubuntu linux OS. I would like to run my application directly on the Samsung handset device, so I performed the following setup steps:
in my project AndroidManifest.xml file, added android:debuggable="true" to the <application> element
On the device, in the Settings > Security enabled Unknown sources
On the device, in the Settings > Developer options enabled USB debugging
On my computer, created the /etc/udev/rules.d/51-android.rules file with the following content:
SUBSYSTEM=="usb", ATTR{idVendor}=="04E8", MODE="0666", GROUP="plugdev"
On my computer, run the chmod a+r /etc/udev/rules.d/51-android.rules command
Then, on my computer I opened a terminal and executed the adb devices command, I got:
List of devices attached
???????????? no permissions
Since I did not see my device but only ???????????? no permissions, I then run the following commands:
adb kill-server
adb start-server
adb devices
But I still got:
List of devices attached
???????????? no permissions
Why? What am I missing?
What works for me is to kill and start the adb server again. On linux: sudo adb kill-server and then sudo adb start-server. Then it will detect nearly every device out of the box.
Nothing worked for me until I finally found the answer here:
http://ptspts.blogspot.co.il/2011/10/how-to-fix-adb-no-permissions-error-on.html
I'm copying the text here in case it disappears in the future.
Create a file named /tmp/android.rules with the following contents (hex vendor numbers were taken from the vendor list page):
SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0e79", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0502", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0b05", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="413c", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0489", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="091e", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="12d1", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="24e3", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2116", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0482", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="17ef", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1004", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="22b8", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0409", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2080", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0955", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2257", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="10a9", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1d4d", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0471", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04da", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="05c6", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1f53", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04e8", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="04dd", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0fce", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="0930", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="19d2", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="1bbb", MODE="0666"
Run the following commands:
sudo cp /tmp/android.rules /etc/udev/rules.d/51-android.rules
sudo chmod 644 /etc/udev/rules.d/51-android.rules
sudo chown root. /etc/udev/rules.d/51-android.rules
sudo service udev restart
sudo killall adb
Disconnect the USB cable between the phone and the computer.
Reconnect the phone.
Run adb devices to confirm that now it has permission to access the phone.
Please note that it's possible to use , USER="$LOGINNAME" instead of , MODE="0666" in the .rules file, substituting $LOGINNAME for your login name, i.e. what id -nu prints.
In some cases it can be necessary to give the udev rules file a name that sorts close to the end, such as z51-android.rules.
Enter the following commands:
# cd to adb for sudo
cd `which adb | sed -e "s/adb//"`
adb kill-server
sudo ./adb start-server
./adb devices
This happens when you are not running adb server as root.
Tried all above, none worked .. finally worked when I switch connected as from MTP to Camera(PTP).
There are a lot of bad answers posted to this question ranging from insisting on running adb as root (which should not be touted as the only or even recommended solution) to solving completely unrelated issues.
Here is the single shortest and most universal recipe for taking care of permissions for all adb and fastboot devices at once:
echo 'ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ENV{ID_USB_INTERFACES}=="*:ff420?:*", MODE="0666"' | sudo tee /etc/udev/rules.d/99-android.rules
sudo udevadm control --reload-rules
sudo udevadm trigger --verbose --action=add --subsystem-match=usb
Or you could use slightly longer version I posted to this gist.
As for the specific thing that OP did wrong in his question - it was not reloading the udev rules after editing the .rules file.
Also OP did not tell which Android build (aka ROM) he had on his phone. The idVendor value is set in software and therefore it depends on the ROM. So the value of 04E8 he used in his original rule would have worked only for devices with Samsung stock ROMs. But this is not a problem for this udev rule - it matches all devices with adb or fastboot interfaces regardless of their VendorID.
In Archlinux this can happen occasionally. The fix:
$ sudo -s
# adb kill-server
# adb start-server
For those using debian, the guide for setting up a device under Ubuntu to create the file "/etc/udev/rules.d/51-android.rules" does not work. I followed instructions from here. Putting down the same here for reference.
Edit this file as superuser
sudo nano /lib/udev/rules.d/91-permissions.rules
Find the text similar to this
# usbfs-like devices
SUBSYSTEM==”usb”, ENV{DEVTYPE}==”usb_device”, \ MODE=”0664″
Then change the mode to 0666 like below
# usbfs-like devices
SUBSYSTEM==”usb”, ENV{DEVTYPE}==”usb_device”, \ MODE=”0666″
This allows adb to work, however we still need to set up the device so it can be recognized. We need to create this file as superuser,
sudo nano /lib/udev/rules.d/99-android.rules
and enter
SUBSYSTEM==”usb”, ENV{DEVTYPE}==”usb_device”, ATTRS{idVendor}==”0bb4″, MODE=”0666″
the above line is for HTC, follow #grebulon's post for complete list.
Save the file and then restart udev as super user
sudo /etc/init.d/udev restart
Connect the phone via USB and it should be detected when you compile and run a project.
I had the same problem, the solution is as fellow: (by the way, you don't have to root your device.)
Type "su" to switch to super user.
your-path/adb kill-server.
your-path/adb start-server.
If no error occurs, you can see the device list with "your-path/adb devices" in root account.
Quit super user.
Now you can perform "adb devices" in your account.
Enjoy.
I know this might be a little late but here is a very good article on how to manually add Android ADB USB Driver. Manually adding Android ADB USB driver in Ubuntu 14.04 LTS
Edited to Add Link Content
Steps
Note: Make sure that you have connected your Android device in USB Debugging mode
Open terminal (CTRL + ALT + T) and enter command:
lsusb
Now you might get a similar reply to this:
Bus 002 Device 013: ID 283b:1024
Note:
With reference to this Bus 002 Device 008: ID 283b:1024
{idVendor}==”283b”
{idProduct}==”1024″
Now enter the following command:
sudo gedit /etc/udev/rules.d/51-android.rules
This creates the android rules file (51-android.rules) or open the existing one in the specified location (/etc/udev/rules.d)
Add a new line to this file:
SUBSYSTEM==”usb”, ATTRS{idVendor}==”283b”, ATTRS{idProduct}==”1024″, MODE=”0666″
Note Edit idVendor & idProduct values with your device values.
Save and close.
Now enter the following command:
sudo chmod a+rx /etc/udev/rules.d/51-android.rules - grant read/execution permission
sudo service udev restart - Restart the udev service
Now we have to add the idVendor to adb_usb.ini. Enter the following commands:
cd ~/.android
gedit adb_usb.ini
Add the following value
0x283b
This is nothing but 0x(idVendor value). So replace the value with. respect to your device value
Save and close the file.
Now enter the following command:
sudo service udev restart
Plug out the Android device and reconnect it again.
Now enter the following command:
adb kill-server
adb devices
There you go! Your device must be listed.
Copied From Manually adding Android ADB USB driver in Ubuntu 14.04 LTS
Worked for me.
I had the same problem with my Galaxy S3.
My problem was that the idVendor value 04E8 was not the right one.
To find the right one connect your smartphone to the computer and run lsusb in the terminal. It will list your smartphone like this:
Bus 002 Device 010: ID 18d1:d002 Google Inc.
So the right idVendor value is 18d1. And the line in the /etc/udev/rules.d/51-android.rules has to be:
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
Then I run sudo udevadm control --reload-rules and everything worked!
Use the M0Rf30/android-udev-rules GitHub community maintained udev-rules
https://github.com/M0Rf30/android-udev-rules/blob/master/51-android.rules
This is the most complete udev-rules list I've seen so far, even more than the currently recommended sudo apt-get install android-tools-adb on the official documentation, and it solved that problem for me.
Follow the instructions at http://developer.android.com/guide/developing/device.html(Archived link)
Replace the vendor id of 0bb4 with 18d1 in /etc/udev/rules.d/51-android.rules
Or add another line that reads:
SUBSYSTEM=="usb", SYSFS{idVendor}=="18d1", MODE="0666"
Restart computer or just restart udev service.
When you restart udev, kill adb server & start adb server goto android sdk installation path & do all on sudo. then run adb devices it will solve permission problem.
My device is POSITIVO and my operational system is Ubuntu 14.04 LTS
So, my problem was in variable name
I create the file /etc/udev/rules.d/51-android.rules
and put SUBSYSTEM=="usb", SYSFS{idVendor}=="1662", MODE="0666"
I disconnected device
and execute:
$ sudo udevadm control --reload-rules
$ sudo service udev restart
after this i connected the android device in developer mode again and
$ adb devices
List of devices attached
1A883XB1K device
Without unplugging
All the provided answers assume that you are able to unplug and reconnect the USB cable. In situations where this is not possible (e.g., when you are remote), you can do the following to essentially do what the suggested udev rules would do on re-plug:
lsusb
Find the device you care about, e.g.:
Bus 003 Device 005: ID 18d1:4ee4 Google Inc. Nexus
Take note of the bus number it is on and then execute, e.g. for bus 003:
sudo chmod a+w /dev/bus/usb/003/*
Clearly this may be more permissive than you want (there may be more devices attached than just this one), but you get the idea.
You should NOT run adb server as root as other answers are suggesting. Instead if you are using Arch Linux do the following:
Install the android-udev package with Pacman
Reload udev rules:
# udevadm control --reload-rules
Add yourself to adbusers group and then logout and login:
# usermod -aG adbusers $LOGNAME
Source: https://wiki.archlinux.org/index.php/android#Configuring_adb
Please DO NOT follow solutions suggesting to use sudo (sudo adb start-server)! This run adb as root (administrator) and it is NOT supposed to run like that!!! It's a BAD workaround!
Everything running as root can do anything in your system, if it creates or modify a file can change its permission to be only used by root. Again, DON'T!
The right thing to do is set up your system to make the USER have the permission, check out this guide i wrote on how to do it properly.
Only for Ubuntu/ Debian users:
There are some specific things to do for ubuntu to make USB debugging work:
described here:
https://developer.android.com/studio/run/device
Here are the two steps mentioned. Run this two command in terminal:
sudo usermod -aG plugdev $LOGNAME
sudo apt-get install android-sdk-platform-tools-common
Try instead of GROUP="plugdev" use the main group of your user.
In my case on ubuntu 12.04 LTS, I had to change my HTC Incredible usb mode from charge to Media and then the device showed up under adb. Of course, debugging was already on in both cases.
I had the same problem and I followed these steps:
# Clone this repository
git clone https://github.com/M0Rf30/android-udev-rules.git
cd android-udev-rules
# Copy rules file
sudo cp -v 51-android.rules /etc/udev/rules.d/51-android.rules
# OR create a sym-link to the rules file - choose this option if you'd like to update your udev rules using git.
sudo ln -sf "$PWD"/51-android.rules /etc/udev/rules.d/51-android.rules
# Change file permissions
sudo chmod a+r /etc/udev/rules.d/51-android.rules
# If adbusers group already exists remove old adbusers group
groupdel adbusers
# add the adbusers group if it's doesn't already exist
sudo mkdir -p /usr/lib/sysusers.d/ && sudo cp android-udev.conf /usr/lib/sysusers.d/
sudo systemd-sysusers # (1)
# OR on Fedora:
groupadd adbusers
# Add your user to the adbusers group
sudo usermod -a -G adbusers $(whoami)
# Restart UDEV
sudo udevadm control --reload-rules
sudo service udev restart
# OR on Fedora:
sudo systemctl restart systemd-udevd.service
# Restart the ADB server
adb kill-server
# Replug your Android device and verify that USB debugging is enabled in developer options
adb devices
# You should now see your device
The above steps are described on android-udev-rules. It worked for me.
Just be sure to confirm the dialog that will appear on your phone screen after replug it.
sudo usermod -aG plugdev $LOGNAME
This command worked for me
When you connect usb to computer, it asks you if you trust the computer to debug apps on the phone. Clicking yes solved the problem
This was driving me bananas. First and foremost some of the really old suggestions here can brick your arch linux system. I had to boot from a rescue USB to undo the rules hacks. In my facepalm of a case, i couldn't get my android to prompt for authorizing the host when plugged into USB and had the same symptom as everyone else:
$ sudo adb devices
List of devices attached
89MY08NPA no permissions; see [http://developer.android.com/tools/device.html]
being root didn't matter.
Go into your android's USB settings and make sure Use USB for is set to File Transfer. Mine was set to no data transfer for some reason even though I've been doing android dev on this phone for years. Some update from Google must have flipped it to another setting.
Once you set it to file transfer you get promted to allow debugging from the host and back to normal
I had tryed some of the aforementioned solutions:
restart adb server
amend 51-android.rules
add myself to adbusers group
and it worked once. The device asked me to authorize the PC and afterwards, everything was working OK.
The issue was when I tried to connect the device after the PC reboot, that Again the issue was the same.
In order to vercome now this issue I had to manually revoke Settings->Developer Options->USB debugging authorizations and then the device asked me again to authorize the PC, and thus finally worked.
One other time the aforementioned solution with revoking USB debugging authorization didn't wokred, and in order to trigger authentication of the device I had to manually disable/enable the
Settings->Developer options->USB debugging
I am using ubuntu 20.04LTS.
If you are on debian like Ubuntu, deepin etc based distro you can try to run
sudo apt-get install android-sdk-platform-tools-common
Voila your problem solved
I used su and it started working. When I use Jetbrains with regular user, I see this problem but after restarting Jetbrains in su mode, I can see my device without doing anything.
I am using Ubuntu 13.04 and Jetbrains 12.1.4
You could also try editing adb_usb.ini file, located at /home/username/.android/. This file contains id vendor list of devices you want to connect. You just add your device's id vendor in new line (it's one id per line). Then restart adb server and replug your device.
It worked for me on Ubuntu 12.10.
Anyway, what I did to solve this problem(on Ubuntu).
Defined in what cases I need to run these commands. For most ubuntu users there is a home folder (hidden file .bashrc).
In which you can record the launch of these commands. But these commands will be triggered when you enter the bash command in the console.
Since I have a shell .zshrc then I did the following:
open console: gedit .zshrc
When the file opens, add the following line:
./.add_device_permissions.sh
After or before, we need to create this file: .add_device_permissions.sh in which we write the following:
#!/bin/bash
# Add permissions
ADB="/home/vadimm/Android/Sdk/platform-tools/adb"
$ADB devices
$ADB kill-server
cat .permissions_redmi_note | sudo -S $ADB devices
$ADB kill-server
cat .permissions_redmi_note | sudo -S $ADB devices
Also we need create .permissions_redmi_note where we need to hardcode our password.
Not to add to the file .zshrc unnecessary we can specify the path when starting the system itself: Startup Applications Preferences
Where we press on "Add" and write our command: /home/vadimm/.add_device_permissions.sh
Also u can tried use in command line next commands:
./adb devices
./adb kill-server
sudo ./adb devices
./adb kill-server
./adb devices
If anyone faces the following error message when they use adb devices
no permissions (verify udev rules); see [http://developer.android.com/tools/device.html]
Execute the following
sudo -s
adb kill-server
adb start-server
That fixed the issue for me on a custom build android device
I am currently using RHEL 5 and need to connect my Nexus 4 to my PC with USB debugging enabled (done) so that I can run my android projects directly on the phone rather than the emulator which is very slow and painfully time consuming. I have updated my Android SDK manager and noticed that I did not find any Google USB drivers as those available in Windows. Some more Googling and I came across some steps to be followed to accomplish this in Ubuntu:
1. sudo lsusb
2. get the two hex values sepearetd by a ':'(This is the manufacturerID:deviceID you need to tell the system to handle)
3. Then as root, do the following:
sudo su -
cd /etc/udev/rules.d
vi 51-android.rules
In this file, add a line that enables you to handle your device. Problem is: I do not have this file in my rules.d folder. So what is the procedure for making my device recognizable in any other linux distro (in my case RHEL 5).
Also, when I do this :
adb devices
output:
List of devices attached
???????????? no permissions
Please Help. Thanks in Advance :)
You can change the permissions of adb executable to be able to access usb.
Try first, if adb works properly, when using it with root permission:
sudo ./adb kill-server
sudo ./adb start-server
sudo ./adb devices
If you do not have 'sudo' installed on your system, just do the operations above with the root user. If it works, you can use the following workaround to make it work permanently:
chown root:user_group adb
chmod 4550 adb
After this it should work.
You'll have to create the file from scratch and insert the line, otherwise it won't work.
Follow the instructions that you have found and you are safe.
The adb devices will show your device properly if you follow the steps.
I've run into this problem too, when using RHEL/CentOS 6.6, where no plugdev group is present.
I run adb with unprivileged user account myuser.
My solution was to create the /etc/udev/rules.d/50-android.rules file with the rules:
# udev rules for USB android devices
# samsung: 04e8
SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", MODE="0666", GROUP="myuser"
# LG: 1004
SUBSYSTEM=="usb", ATTR{idVendor}=="1004", MODE="0666", GROUP="myuser"
After which I did (as root):
udevadm control --reload-rules ; udevadm trigger
and then, as myuser:
adb kill-server
adb devices -l
The explanation: the GROUP= option in the udev rules file specifies the group which will own the device when plugged in. In Debian-based distributions there is a plugdev group which fulfills this purpose, but some newer RHEL-based distros don't have it. This creates a permissions problem when adb is run with a regular (non-root) user, since it won't have access to the devices.
The solution is to assign the USB devices to a group which exists, and to which your linux user belongs. In my case I chose to assign the device to my user's "personal" group, to which it has the proper permissions.
Another solution (untested, but should work the same) would be to create the plugdev group and add your user to it.