Remote debugging with Android emulator

Remote debugging with Android emulator - android

Is it possible to write the code/compile Android application on one machine and debug it remotely on the emulator launched on another? I'm sick and tired of the emulator constantly eating half of my laptop's CPU.

I haven't previously tried (or even noticed) the adb connect command that cmb mentioned, but I can confirm that forwarding the TCP ports yourself — such as over SSH — works fine.
The emulator listens on two TCP ports per instance: 5554 for the telnet interface and 5555 for control communication with tools like DDMS. So you could probably get away with only forwarding port 5555 (though I've only tried it so far with both). Each subsequent emulator takes the next available even+odd port number tuple (up to around 5580, I think).
For reference, I did the following steps on my local machine:
ssh -NL 5554:localhost:5554 -L 5555:localhost:5555 myuser#remote-server
killall adb; adb devices
I believe the emulator tries to notify a local adb server at startup; hence the need to restart adb in order for it to probe the local 5554+ ports.
Note that the localhost in the ssh command refers to the local interface of the remote machine.
adb devices showed a new emulator — emulator-5554 — and I could use it as if it were running on my local machine.

I realize this question is really old, but I solved the problem slightly differently, and it took me a while to figure out this trivial solution.
I usually use a Windows7 PC or laptop (depending on where I'm working) as my front-end because I like the GUI, however I prefer to do all of my edit/compile/debug on a headless Ubuntu server because of all the command-line power it provides. My goal is to make each windows system as much of a thin-client as possible without any extra services (such as sshd) or firewall holes.
So here is the senario:
System-A: Windows7 system with android emulator running
System-B: Ubuntu server with SDK installed
The problem as described earlier is that the emulator on System-A binds to localhost, not the external ethernet interface, so adb on the System-B cannot access the emulator on System-A. All you need to do is set up remote port forwarding in PuTTY for your SSH connection to System-B. The trick is to check the "Remote" radio button when you create the two tunnels so that the tunnel direction is reversed (tunneling from the server you are logging into to the client you are logging in from).
Finally, connect with adb to "localhost" on System-B after establishing the SSH connection:
System-B$ adb connect localhost
connected to localhost:5555
System-B$ adb devices
List of devices attached
localhost:5555 device
Now you can download images/debug as normal, and it is a trivial matter to switch to a different Windows system if you want to take your laptop out and get some coffee.
In addition, by also tunneling port 5037 in the same manner you can actually forward your adb server connection so that you can connect a real android device over USB on System-A, and download images to it from System-B. In order for this to work, you need to make sure that the adb server is running on System-A, and not running on System-B before starting your SSH session:
First, start the adb server on System-A (command prompt)
C:\> adb start-server
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
C:\> adb devices
List of devices attached
3435F6E6035B00EC device
Next, kill the adb server on System-B
System-B$ adb kill-server
Finally, restart your ssh session to System-B and verify
System-B$ adb devices
List of devices attached
3435F6E6035B00EC device

Here is how I solved it on Windows. I pretty much followed Christopher's lead, but I can't edit, so a new answer will have to do.
The problem I had was that ADB as well as the emulator was just listening on 127.0.0.1, not 0.0.0.0, for me. Otherwise I would have used TCPMon. I guess this is either different on Windows, or has changed with the latest versions of the SDK. (You can check with netstat -ban.)
I installed WinSSHD on the machine that runs the emulator. (I believe it should work with freeSSHd as well, but I couldn't get a login working there.)
I opened port 22 (TCP) in the Windows Firewall. (WinSSHD might be able to do that for you.)
I created a virtual account in the WinSSHD GUI.
I created a new PuTTY connection from the development machine to the emulator machine and made sure I could connect.
Then I set up tunnelling in PuTTY: Connection -> SSH -> Tunnels
Source port: 5554
Destination: localhost:5554
Type: Local/Auto
Source port: 5555
Destination: localhost:5555
Type: Local/Auto
(Connect and keep PuTTY open, to maintain the tunnel.)
Now I fired up the emulator on the remote machine and made sure that ADB is not running there.
I restarted ADB on the development machine (adb kill-server, then adb start-server).
adb devices and the remote emulator showed up as emulator-5554 device. I could now deploy and run my app straight from Eclipse/ADT, where the emulator showed up under Virtual Devices as if it was a local emulator.

I found an easy way to do this if your two machines are in the same private network and therefore do not need to use SSH encryption (which is the common case). This may help as an SSH tunnel can be quite long and difficult to install. For example, installing an SSH daemon under Cygwin / Windows for the first time may lead to give up (well, I gave up).
Under Windows, what follows requires having Cygwin installed with the package httptunnel. This must work under Linux / httptunnel as well but I didn't try.
Run the emulator on one of the machines (let's say its host name is HostEmulator)
Start Eclipse on the other machine (let's call it HostEclipse)
Open a Cygwin terminal on each machine, and then,
On HostEmulator, enter the following cygwin commands:
hts -F localhost:5554 10000
hts -F localhost:5555 10001
hts means Http Tunnel Server.
These two commands create two half-bridge that listen to the ports 10001 and 10001 and that redirect the I/O of these ports to the local ports 5554 and 5555, which are the ports used by the emulator (actually, the first lauched emulator - if you are several of them running they will use higher port numbers as seen in other replies of this page).
On HostEclipse, enter these ones:
htc -F 5554 HostEmulator:10000
htc -F 5555 HostEmulator:10001
htc means Http Tunnel Client.
These commands create the missing half-bridges. They listen to the local ports 5554 and 5555 and redirects the I/O of these ports to the half-bridges we have created on HostEmulator just before.
Then, still on HostEclipse, enter these three commands:
adb kill-server
adb start-server
adb devices
This restarts adb as it doesn't detect the remote emulator otherwise. It must be doing some scanning at startup. And then it lists the devices (the available emulators) just for checking.
And there you go.
You can work with your remote emulator as if it was local.
You have to keep the Cygwin terminals open on both machine otherwise you would kill the half bridges you created.
I used the port 10000 and 10001 for the machine/machine exchanges here, but of course you can use other ports as long as they are not already in use.

None of the proposed solutions worked for me.
I've started from Emirikol's solution and refined it, as with the new Android API > 21 the emulator was appearing offline and I had to go to Genymotion settings and leave Android SDK path empty.
And from command line:
netsh interface portproxy add v4tov4 listenport=5555 connectport=5555 connectaddress=<emulatorIP>
netsh interface portproxy add v4tov4 listenport=5554 connectport=5554 connectaddress=<emulatorIP>
source:http://www.sarpex.co.uk/index.php/2016/10/02/connect-genymotion-emulator-remotely/
Disclaimer, I'm the author.

When you run adb, it starts a server copy of itself if one isn't already running.
You can start that copy yourself on the machine with the device and since sdk 4.3 you can give it the -a option to tell that server to listen for remote machines. Do that with the following command which doesn't exit:
adb -a -P 5037 server nodaemon
On the machine you want to use the device from, set ADB_SERVER_SOCKET to tcp:xxxx:5037 in an environment variable (or give the same value to each adb invocation with the -L option), where xxxx is the IP address or hostname of the machine with the devices, and 5037 matches the port you gave the in the command above.
We use this to give access to about 100 emulators spread over 3 machines to a machine running end to end tests in parallel, and to developers wanting to share real devices remotely.
You can forward ports to and from the emulator with adb forward and adb reverse, and they'll appear on the machine with the devices (not the machine you're running 'adb forward' from).

My solution for windows + AndroVM (which requires a host-only adapter) when my ssh service failed to start. so it doesn't require any additional software.
adb connect <Andro VM IP>
adp tcpip 555
On cmd prompt run as admin:
netsh interface portproxy add v4tov4 listenport=5555 listenaddress=<host ip> connectport=5555 connectaddress=<Andro VM IP>
open TCP port 5555 in windows firewall.
Then, from the second PC run:
adb connect <host ip>

This post contains many answers but step by step instructions are missing.
So this answer will explain how to connect 2 computers to run projects of one computer on the emulators of another computer.
Requirements before going further:
Firewall should be off in both the PCs.
Both PCs must be connected in the same network.
Notes:
Computer running Android Studio is mentioned as "PC_AS"
Computer running Emulator is mentioned as "PC_EM"
Step 1:
On the computer running Android Studio, open a terminal window and run following command.
ssh -NL 5554:localhost:5554 -L 5555:localhost:5555 dhaval#192.168.0.104
Above command will forward 5554 and 5555 ports of PC_AS to the same ports on PC_EM. So the emulators running on PC_EM can be detected on the PC_AS.
dhaval#192.168.0.104 is the address of the PC_EM. Format of the address is username#local_ip_address
Once you run above command, the terminal window will not show anything if the command is executed successfully. It will look like nothing is going on but the process is running there.
| 💡 Note: Do not close this terminal until you want to stop remote debugging.
Step 2:
Now open another terminal window on PC_AS and run following commands one by one.
killall adb;adb devices
This command will stop the adb and stop the server.
adb start-server
This command will start the adb server.
adb devices
This command will list down all the connected adb devices.
Once you run above commands, you will see that emulators of PC_EM are now detected in the PC_AS. Now you can run the projects on those emulators and debug remotely.
| 💡 Note: While doing the above process, emulators can show a dialog to trust the incoming request.

Android emulators by default listens on local port 5555, so one way to connect to a remote emulator is by using a port forwarding tool to forward all LAN packets to local 5555 port.
One such excellent tool is Trivial Port Forward
Here is the command:
trivial_portforward.exe 1234 127.0.0.1 5555
Here 1234 is the port number where the development computer will connect. 127.0.0.1 is loopback address and 5555 is the emulator’s port.
For more detailed example, see my blog post.

This is how I made it work from host macOS with emulator to macOS client.
A: One line command
On host of emulator
socat tcp-l:5560 tcp:localhost:5559
On client
adb connect <IP>:5560
B: With a tunnel
on host with Emulator
host$ adb kill-server
host$ adb -a nodaemon server
on client with Android Studio
client$ adb kill-server
client$ ssh -L 5037:localhost:5037 <host-IP>
open second shell on client with Android Studio
client$ adb kill-server # I observe first it kills client adb
client$ adb kill-server # then it kills server adb, do it maybe once more
client$ adb devices # show devices on server now
Now I see host emulator in Android Studio as well

I don't have a second machine with the SDK to hand, but I note that the emulator's listen ports (default 5554, 5555) are listening on 0.0.0.0, i.e. reachable from remote machines, and that adb --help shows a connect <host>:<port> command. I assume that would make it show up in adb devices so adb commands work on it. For Eclipse, try "Run / Run Configurations..." and set the Target to Manual. That gives you a "device chooser" which I'm guessing would include a remote emulator if adb is connected to it. Worth a try.

Related

ADB devices is empty in windows docker container

This is the output of adb devices inside a docker container (a windows server image - also the host is win 10)
PS C:\> adb devices
List of devices attached
PS C:\>
I need to create CI for a Xamarin project, all is done except the part where I need to install the app on the phone via adb....until now I found no solution to use adb from inside a win docker contaienr (for linux there is the option to --privileged -v /dev/bus/usb:/dev/bus/usb, but switching to Linux is not an option( due to company decisions))

ADB can connect to the device over WiFi and from a networking aspect Docker shouldn't cause any problems for this as long as the network of the Docker Host machine can send traffic to the network of the Android device (if they are the same network, then the answer is definitely yes).
First make sure that the Docker Host machine can reach your device over the WiFi network. A test like pinging the IP of your Android device from the Docker Host machine would work. After that, initiate the ADB over WiFi using the ADB on your Docker Host machine (not the one in your container).
adb tcpip 5555
Once that is done, open a terminal in the container and connect to the Android device using the ADB inside the container.
adb connect <ip-address-of-android-device>
adb devices
Usually, when a new connection is established from an "un-trusted" machine, the device requests the user to confirm the connection and so "trust" the machine. An adbkey is created under %userProfile%/.android on the machine which the device uses to establish a trust every time the connection is made after the first time it happens so that the user doesn't need to confirm the connection every time. Copy or volume bind the adbkey into the <container_userProfile_directory>/.android so device doesn't request from the user to confirm the connection every time.

Until android 5 or 6 you need a driver for adb. Most brands give it free to download on their website.
And if you haven't done it yet, you should enable Adb-Debugging via USB in the developer options on the phone.

For adb you'll have to open the TCP port in the Dockerfile with EXPOSE 5037 (default).

Implementing USB sharing over network

I set out to see if I can configure my development environment such that I can run adb commands from my dev box in the office network on an Android device that is connected to the USB port of my laptop which is in the same LAN (or connected via VPN). I specifically wanted the adb server to be running on the dev box and communicating to the adb daemon on my device over the network. I didn't want to connect the adb client that runs on the dev box to the adb server running on my laptop which the adb tool allows via its -H option and I didn't want to use the adb connect or adb tcpip commands. Basically, I just wanted to relay the adb communication that happens over the USB cable to happen over the network (SSH tunnel).
As a proof of concept, I managed to build a prototype using a third party solution that would allow me to share USB over network but now I want to see if I can build the same solution using port forwarding and some coding. However, my technical knowledge of USB drivers, OS kernels, and how the USB communication works (on Linux and Mac) is very basic so I am hoping to find some answers from the community.
Question: Where in the USB stack do I need to start creating hooks so I can forward all data communication of a certain USB port to a different process running in the same OS?
Proposal: If I can find the port numbers that the USB drivers on each machine communicate to the process in the kernels that then forwards the data to the application, I can use port forwarding on each machine to re-route the communication to a daemon process running on each machine that then wraps the data in TCP/IP and transfers over the network. The image below depicts this scenario:
The adb server that runs on the client machine will need to be configured to route its communication to a port on the client machine that an damon emulator process listens. This daemon process will then have to transmit the data over the network to another daemon process running on the server machine that hosts the Android device via a USB port. The latter daemon process listening to the same port that the client machine send out TCP/IP data will then read the data, transforms it to adb protocol, and sends the data to the USB device. The parts of this solution that I am trying to learn more about is how to write a daemon process that acts as a USB device emulator. Any help or recommendations for further reading is appreciated.

I found a very easy fix to this problem. I was able to get this working by running the commands below.
On my remote development machine: ($remote_host)
adb kill-server
On my laptop:
adb kill-server
adb start-server
ssh -N -R 5307:localhost:5307 $remote_host
And, finally on my remote development:
adb start-server
I was then able to run adb devices on my remote machine (using an SSH tunnel) and see the SN of the device that is connected to my laptop.

ADB over TCP - Devices are connected and online but installing shows Error: Device not found

Good day,
I've been using a VMWare android machine and installing .apks on it but after my computer was unexpectedly shut down and tried to re-install a package I've been having the following problem:
$ adb -s 192.168.1.2 install 'myapp.apk'
error: device not found
- waiting for device -
However I was able to connect the VM using adb connect 192.168.1.2 which is the ip currently assigned on the android, (seen it on ctrl+f1 netcfg) and then shows:
connected to 192.168.1.2:5555
$ adb devices
List of devices attached
emulator-5554 offline
192.168.1.2:5555 device
so it appears to be online.
Troubleshooting steps taken before posting:
$adb kill/start-server
Reconfigured the VM Network (I have it bridged and Internet connection works fine).
-Suspending/Shutting down and Restarting VM.
-Restarting Internet connection (Router/PC connections)
Kindly assist with situation or post links of another issue related to mine that I probably did not find (sorry for that..)
Thanks!
Edit: I'm using Fedora as OS, Eclipse for developing

When using an ADB tcp target, the device name specified in the -s parameter must include not only the IP address but the port as well, for example:
adb -s 192.168.1.2:5555 install 'myapp.apk'
(As the android emulator actually talks over TCP behind it's "emulator-####" name, one can test this by connecting to an emulator at the loopback address using the control port plus one, ie, "emulator-5554" can also be reached as a vanilla tcp target via adb connect 127.0.0.1:5555 and then you can install on it with adb -s 127:0.0.1:5555 install whatever)

Debug device connected by USB to VirtualBox's host, from Android-Studio inside VM

I am trying to get mono for android (aka monodroid) working within a windows 7 virtual machine on virtualbox but I am having issues with the adb connection to my phone. When I run "adb devices" to list the devices present it show up no problem, but when I attempt to run an "adb install", logcat, or push it hangs. Currently there is a bug in virtualbox which applies to this but I was hoping someone more knowledgeable than myself would have a workaround.
https://www.virtualbox.org/ticket/6620
Of coarse non of this would be an issue if Xamarin released a linux port of their product or if I got familiar with Java, but I suppose those are slightly different issues.

Brian, one workaround you might consider is to make your VM host an ADB host as well. Then you can just connect your VM client to it over TCP / IP. Here's the general idea for that setup:
Install the Android SDK on the host machine. You should only require the platform-tools package which includes adb.
Don't allow your VM client to take ownership of the Android device, so disable any VirtualBox USB filter rules you have and it also wouldn't hurt to then detach and reattach the device.
From your VM client, run adb kill-server. Make it a tskill adb for certainty. If you have any running instances of Eclipse, you'll want to shut those down first because it'll actually launch adb in the background. Don't skip this step.
From the host, execute adb devices. If all goes well (and it should), you'll see your device listed. It should look something like this (note the port number and sorry for the mangling):
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
List of devices attached
015d2994ed200409 device
At this point, your host should have an ADB server running at port 5037. You can check this from the VM client by running telnet 10.0.2.2 5037, where 10.0.2.2 is the default IP for VirtualBox hosts and 5037 is the default ADB port noted above.
Now you must either forward the ports from your host to your VM client, or otherwise connect ADB directly to your host IP:port. If you're like me, you'll find the ADBHOST and ANDROID_ADB_SERVER_PORT variables to be poorly documented and easy to screw up. For this reason, consider simple port fowarding over ssh (maybe via Cygwin) like so from the VM client:
autossh -nNL5037:localhost:5037 -oExitOnForwardFailure=yes 10.0.2.2
Finally, run adb devices from your VM client. If you see "daemon not running," it means your port fowarding is screwed up. Otherwise you should see your device and be able to logcat all day. One noteworthy point is that you won't have an adb daemon running on your VM client, except for when you're actually using the debug bridge, of course.
I've used a similar mechanism for debugging devices over the network that are connected to remote machines and it worked well.

Not sure what has changed in VirtualBox since the question was posted, but selecting the usb device from VirtualBox menu Devices -> USB -> DeviceName worked seamlessly. I am working on VirtualBox 5.1.2 r108956.

I was also having trouble with ADB running over VM. I had a Windows 10 host and an Ubuntu 14.04 client. The autossh method did not work for me. I found an easier solution from another StackOverflow question. It requires that both your PC and your device are on the same WiFi network.
On your VM client run the following: adb tcpip 5555
The device will disconnect from the VM because ADB is now in TCP
mode instead of USB.
For the next part you need the IP address of
your device. To find it, simply run adb shell ip -f inet addr show wlan0
Now you can connect to your device. On your VM client, run:
adb connect <Device IP>:5555
From here all my adb shell, logcat, and monkey sessions ran without interruption!

I'm posting this here for people with a setup similar to mine:
Host OS: OSX (10.15.4 Catalina)
Client OS: Windows 10 Enterprise (v1903 build 18362.752)
VirtualBox v6.1.4
Android Studio v3.6.2
To allow Android Studio in client OS (Windows) to connect to an Android phone (using adb) via USB:
Update to latest version of VirtualBox (currently 6.1.4)
Install VirtualBox Extension Pack from here
With the VM powered down, go to Settings > Ports > USB and make sure the USB 3.0 (xHCI) Controller is enabled, then click "OK"
From the host OS (i.e. OSX) open up a terminal and start adb and confirm that the phone is connected by running adb devices
Start up the VM, and from the VirtualBox menu select Devices > USB > [YOUR PHONE] to connect your host OS USB port to the VM
Open up a terminal on the client OS (Windows) and run adb devices to confirm that the adb server is running and can find your phone. You might need to add the Android platform tools to your PATH (mine was at C:\Users\Username\AppData\Local\Android\Sdk\platform-tools). This step might be optional--I suspect that Android Studio might start up adb on its own.
Start up Android Studio in the client OS (Windows) and go to File > Settings > Appearance and Behavior > System Settings > Android SDK > SDK Tools and make sure that the Google USB Driver is installed (see screenshot here)
After I did these things, Android Studio was able to detect my phone and run/debug apps using that device.
Hope this helps!

I had the same problem and it made me search for about 2 hours.I tried several approaches including all above solutions but none of them worked
My situation
My host was archlinux and the guest was windows 8.1 I was running flash builder in windows but the usb debugging wouldn't work and my connected device was nexus 5 so i followed these steps
Enable USB controller from virtualbox menu Machine-->settings-->usb enable usb controller and enable USB 2.0 (EHCI) controller then add your device(click on + button on right side) then start your virtual machine
Now you should download the latest google usb drivers from here and extract it
Go to control panel device manager right click on your device go to driver tab and click on Update driver there should be two option one search automaticly ... and another browse my computer choose the second one and give the extracted file path(check the Included subfolders option) after this your device should be recognized by windows and there will be a message in your android device for allowing access to your device
In my case i should copy the drivers to flashbuilder android drivers path too but maybe for your situation this isn't necessary

I had same problem with VirtualBox 5.0.14 and solution provided by Stephen Niedzielski didn't work for me. If someone is still interested can try this solution.
My environment is:
Host OS: Mac OS 10.11
Guest OS in VirtualBox: Ubuntu 14.04
Device: Galaxy S5 running Cyanomodgen 12.1
Start a wifi hotspot in host OS and connect there the android device, or connect both in a router. In virtualbox set network mode for guest OS to 'Bridged Adapter' and then select name of Wifi adapter. In that way host OS and android device are in same network.
Then, in android device activate 'Developer mode' and enable 'ADB over network', provided from Cyanomodgen. (For devices with original version of android, google how to use ADV over network if possible)
In host OS run 'adb kill-server' and make sure no instance of ADB is running. Then run command 'adb connect 192.168.2.12', ip of android device.
Congrats :) Now you are are able to use ADB with android device to take logcat or pull and push files.

Install the Android SDK on the host machine. You should only require the platform-tools package which includes adb.
Don't allow your VM client to take ownership of the Android device, so disable any VirtualBox USB filter rules you have and it also
wouldn't hurt to then detach and reattach the device.
From your VM client, run adb kill-server. Make it a tskill adb for certainty. If you have any running instances of Eclipse, you'll
want to shut those down first because it'll actually launch adb in
the background. Don't skip this step.
From the host, execute adb devices. If all goes well (and it should), you'll see your device listed. It should look something like
this (note the port number and sorry for the mangling):
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
List of devices attached
015d2994ed200409 device
At this point, your host should have an ADB server running at port
5037. You can check this from the VM client by running telnet 10.0.2.2 5037, where 10.0.2.2 is the default IP for VirtualBox hosts and 5037 is the default ADB port noted above.
(https://stackoverflow.com/a/12557836/16902966)
and in the virtual machine (Windows):
set ADB_SERVER_SOCKET=tcp:10.0.2.2:5037
Connected device(s): ...\platform-tools>adb.exe devices .

Run/install/debug Android applications over Wi-Fi?

I thought there was a way to test your applications in development over Wi-Fi. Is this possible?
I'd love to be able to untether my phone and develop wirelessly.

See forum post Any way to view Android screen remotely without root? - Post #9.
Connect the device via USB and make sure debugging is working;
adb tcpip 5555. This makes the device to start listening for connections on port 5555;
Look up the device IP address with adb shell netcfg or adb shell ifconfig with 6.0 and higher;
You can disconnect the USB now;
adb connect <DEVICE_IP_ADDRESS>:5555. This connects to the server we set up on the device on step 2;
Now you have a device over the network with which you can debug as usual.
To switch the server back to the USB mode, run adb usb, which will put the server on your phone back to the USB mode. If you have more than one device, you can specify the device with the -s option: adb -s <DEVICE_IP_ADDRESS>:5555 usb.
No root required!
To find the IP address of the device: run adb shell and then netcfg. You'll see it there.
To find the IP address while using OSX run the command adb shell ip route.
WARNING: leaving the option enabled is dangerous, anyone in your network can connect to your device in debug, even if you are in data network. Do it only when connected to a trusted Wi-Fi and remember to disconnect it when done!
#Sergei suggested that line 2 should be modified, commenting: "-d option needed to connect to the USB device when the other connection persists (for example, emulator connected or other Wi-Fi device)".
This information may prove valuable to future readers, but I rolled-back to the original version that had received 178 upvotes.
On some device you can do the same thing even if you do not have an USB cable:
Enable ADB over network in developer setting
It should show the IP address
adb connect <DEVICE_IP_ADDRESS>:5555
Disable the setting when done
Using Android Studio there is a plugin allowing you to connect USB Debugging without the need of using any ADB command from a terminal.

(No root required) There is one best, easy and with UI method for Android Studio
IntelliJ and Android Studio plugin created to quickly connect your Android device over WiFi to install, run and debug your applications without a USB connected. Press one button and forget about your USB cable.
just install plugin Android WiFi ADB
Download and install Android WiFi ADB directly from
Intellij / Android Studio: Preferences/Settings->Plugins->Browse Repositories
.
Remember! for first time to initialize the device you must have to connect using usb
Alternatively, you can download the plugin from the JetBrains plugin site and install it manually in: Preferences/Settings->Plugins->Install plugin from disk.
You can connect and manage your devices easily....... for more information read here https://github.com/pedrovgs/AndroidWiFiADB

If you want to enable wireless adb on the device without connecting with a USB cable at all (root required):
Install a terminal app on the device (like Android Terminal Emulator)
Type the following
su
setprop service.adb.tcp.port 5555
stop adbd
start adbd
Since you already have the terminal opened, you can find the IP address of the device:
ip addr show
Then in your debugging environment run command:
adb connect ip.of.the.device
This will make the device to be listed as any other emulators you might have. Note that the TCP will stay opened until you reset the device.
You might also want to install a Wi-Fi Keep Alive app if you often experience disconnects.
Remember to close the TCP when connecting to public networks if you want to feel safe. You can do the following or simply restart the device:
su
setprop service.adb.tcp.port -1
stop adbd
start adbd

Update :
Starting from Android Studio Bumblebee (2021.1.1) Stable, you can debug over Wifi just pairing the device by just scanning the QR code.
Quoting from the blog post :
ADB over Wi-Fi: Bumblebee includes a simplified flow to connect to
your Android 11 and higher devices over Wi-Fi for deployment and
debugging using ADB. After you enable debugging over Wi-Fi on your
device, select the Pair using Wi-Fi action in the Physical tab of the
new Device Manager to open the pairing wizard. Then follow the steps
provided to pair to a device connected over the same network. Learn
more.
Old post :
With new Android 11 you can debug your apps over WiFi without using an USB cable at all.
Quoting from Android Studio User Guide
Connect to a device over Wi-Fi (Android 11+)
Android 11 and higher support deploying and debugging your app
wirelessly from your workstation using Android Debug Bridge (adb). For
example, you can deploy your debuggable app to multiple remote devices
without physically connecting your device via USB. This eliminates the
need to deal with common USB connection issues, such as driver
installation.
To use wireless debugging, you need to pair your device to your
workstation using a pairing code. Your workstation and device must be
connected to the same wireless network. To connect to your device,
follow these steps:
On your workstation, update to the latest version of the SDK Platform-Tools.
On the device, enable developer options.
Enable the Wireless debugging option.
On the dialog that asks Allow wireless debugging on this network?, click Allow.
Select Pair device with pairing code. Take note of the pairing code, IP address, and port number displayed on the device (see image).
On your workstation, open a terminal and navigate to android_sdk/platform-tools.
Run adb pair ipaddr:port. Use the IP address and port number from step 5.
When prompted, enter the pairing code that you received in step 5. A message indicates that your device has been successfully paired.
none
Enter pairing code: 482924
Successfully paired to 192.168.1.130:37099 [guid=adb-235XY]
(For Linux or Microsoft Windows only) Run adb connect ipaddr:port. Use the IP address and port under Wireless debugging.

I found my answer here:
Connect Android device and adb host computer to a common Wi-Fi network accessible to both. We have found that not all access points are suitable; you may need to use an access point whose firewall is configured properly to support adb.
Connect the device with USB cable to host.
Make sure adb is running in USB mode on host.
$ adb usb
restarting in USB mode
Connect to the device over USB.
$ adb devices
List of devices attached
######## device
Restart host adb in tcpip mode.
$ adb tcpip 5555
restarting in TCP mode port: 5555
Find out the IP address of the Android device: Settings -> About tablet -> Status -> IP address. Remember the IP address, of the form #.#.#.#.
sometimes its not possible to find the IP-address of the android device, as in my case. so u can get it using adb as the following:
$ adb shell netcfg
and the should be in the last line of the result.
Connect adb host to device:
$ adb connect #.#.#.#
connected to #.#.#.#:5555
Remove USB cable from device, and confirm you can still access device:
$ adb devices
List of devices attached
#.#.#.#:5555 device
You're now good to go!
If the adb connection is ever lost:
Make sure that your host is still connected to the same Wi-Fi network your Android device is.
Reconnect by executing the "adb connect" step again.
Or if that doesn't work, reset your adb host:
adb kill-server
and then start over from the beginning.

The adb utility does have the ability to connect to a device over TCP/IP. However, adbd is not normally listening for TCP connections.
If you want to get it running, you need an engineering device (in other words, you need root). Then follow the directions in this post:
How can I connect to Android with ADB over TCP?
Since this only works on eng devices, it's not officially supported. Use at your own risk, expect bugs, etc.

For all , this , there exists a better method (EASIEST METHOD) :
1 ) A plugin for Android studio exits , called Android wifi ADB
2) Go to file -> settings -> Plugins -> Browse Repositories
3) Look for Android WiFi ADB , click on INSTALL , and then restart on prompt
4) You will see a new icon , which is your new plugin .
Now to make this work :
5) Go to your phone's developer option and enable DEBUGGING (must)
6) Also enable , ALLOW DEBUG OVER TCP/NETWORK
7) Attach your phone via USB , and make sure , both phone and your pc/laptop are connected to the same network (either hotspot or wifi)
8) CLICK ON THE NEW ICON (ie your ANDROID Wifi ABD)
9) Your phone get's detected and get's connected over wifi/hotspot , and hence now you may disconnect the usb . This is a one time process , hence you may not need to keep phone connected over usb .
This will save your phone from irregular charges and also , a remedy for short length usb cables .

In Developer options of Android 11, there is Wireless debugging. Make sure your laptop and phone under same network then execute 2 command below. Note that, the port for pair is different to the port for connect and you just need to pair on the first time (later you just need connect).
adb pair ipaddr:port
adb pair 192.168.1.6:42049
// will output
Enter pairing code: 696686
Successfully paired to 192.168.1.6:42049 ...
adb connect ipaddr:port
adb connect 192.168.1.6:37203
// will output
connected to 192.168.1.6:37203
Addition
These command will only work on android studio terminal, if you are in "platform-tools" directory. cd C:\Users\username\AppData\Local\Android\Sdk\platform-tools>

Install plugin Android WiFi ADB
Download and install Android WiFi ADB directly from Android Studio:
File > Settings->Plugins->Browse Repositories-> Android WiFi ADB ->Install ->Connect with cable for first time -> Click on "Connect" -> Now remove cable and start doing debug/run.
Check ss for your reference :

If you are using Android 11 click on the build version many times to activate the developer option then go to Settings>Advanced>Developer options. Scroll to debugging and turn on the "Wireless debugging" checkbox. Then open the menu debugging by touching the "Wireless debugging". Select "Pair device with paring code" and you will see the address for pairing with a pairing code. write this command in your desktop terminal to pair with your Android device.
adb pair 192.168.XXX.XXX:XXXX <--------- the address showing on screen under paring code
Use the paring code to connect.
But wait we are not connected to adb yet.
After you have successfully paired your device once. You can connect your adb anytime you turn on your Wireless debug option. To connect your adb every time before you use it from now on you don't need the pairing address anymore instead you will use the given address that shows when you enter the Wireless debug menu.
adb connect 192.168.XXX.XXX:XXXX <--- this address shows inside wireless debug menu

After a long search I found :
I must run
adb connect <device_ip_address>:5555
after disconnecting USB.

I wrote a shell script which can let you debug an Android device via Wi-Fi.
Here is the code:
#!/usr/bin/env bash
#Notice: if unable to connect to [ip]:5555,
#try adb kill-server then try again.
adb shell ip route > addrs.txt
#Case 1:Nexus 7
#192.168.88.0/23 dev wlan0 proto kernel scope link src 192.168.89.48
#Case 2: Smartsian T1,Huawei C8813
#default via 192.168.88.1 dev eth0 metric 30
#8.8.8.8 via 192.168.88.1 dev eth0 metric 30
#114.114.114.114 via 192.168.88.1 dev eth0 metric 30
#192.168.88.0/23 dev eth0 proto kernel scope link src 192.168.89.152 metric 30
#192.168.88.1 dev eth0 scope link metric 30
ip_addrs=$(awk {'if( NF >=9){print $9;}'} addrs.txt)
echo "the device ip address is $ip_addrs"
echo "connecting..."
rm addrs.txt
adb tcpip 5555
adb connect "$ip_addrs"

Following steps are standard ones to follow( mostly same as previous answers):-
adb tcpip 5555.
adb connect your_device_ip_address.
adb devices (to see if devices got connected).
But in some cases above steps gives error like "unable to connect to device. Make sure that your computer and your device are connected to the same WiFi network." And you notice the devices are already on the same network.
In this case, install this plugin "Wifi ADB Ultimate" and follow below steps.
Connect the device once through USB.
Refresh the list to check whether its connected.
Go to About Phone > Status > IP Address and note your IP address(e.g. 198.162.0.105).
Come back to Android Studio and fill in this IP as done in below photo and hit the run button.
Now, you are good to go!

To complete the answer of #usethe4ce, if you have more than one device or emulators, the adb tcpip 5555 will give error: more than one device/emulator.
In this case you need to give the serial number of the desired device:
adb devices
List of devices attached
33001229 device
emulator-5554 device
adb -s 33001229 tcpip 5555
Find your device's IP in my case I can find it from the device's wifi connected settings.
adb connect xxx.xxx.xxx.xxx:5555

For Windows:
Step 1. Make a batch file with the below commands and call the file w.bat.
Step 2. Copy the below contents in w.bat, and save it in any of the folders which are in %path% of your Windows system
echo ***Get phone in Wi-Fi mode***
echo ***Get phone in Wi-Fi mode***
adb devices
echo ***Remove cable from the phone now***
adb tcpip 9000
adb connect 192.168.1.1:9000
adb connect 192.168.1.2:9000
adb connect 192.168.1.3:9000
adb connect 192.168.1.4:9000
adb connect 192.168.1.5:9000
adb connect 192.168.1.6:9000
//<-- Till here -->
Step 3. Connect your phone and PC with a cable
Step 4. Ensure the phone is in Wi-Fi mode
Step 5. Remove the cable when the batch file tells you to
Step 6. Type w.bat on the Windows prompt (start -> run -> type CMD, press Enter) (black screen is Windows DOS prompt), if you copied it in one of the path folders then you can run from anywhere, else run from the folder where you created this file.
The output of the batch file will be something like this:
C:\Windows\System32>w
C:\Windows\System32>echo ***Get phone in Wi-Fi mode***
***Get phone in Wi-Fi mode***
C:\Windows\System32>echo ***Get phone in Wi-Fi mode***
***Get phone in Wi-Fi mode***
C:\Windows\System32>adb devices
List of devices attached
d4e9f06 device
C:\Windows\System32>echo ***Remove cable from the Phone now***
***Remove cable from the Phone now***
C:\Windows\System32>adb tcpip 9000
restarting in TCP mode port: 9000
C:\Windows\System32>adb connect 192.168.1.1:9000
unable to connect to 192.168.1.1:9000:9000
C:\Windows\System32>adb connect 192.168.1.2:9000
connected to 192.168.1.2:9000
C:\Windows\System32>adb connect 192.168.1.3:9000
unable to connect to 192.168.1.3:9000:9000
C:\Windows\System32>adb connect 192.168.1.4:9000
unable to connect to 192.168.1.4:9000:9000
C:\Windows\System32>adb connect 192.168.1.5:9000
unable to connect to 192.168.1.5:9000:9000
C:\Windows\System32>adb connect 192.168.1.6:9000
unable to connect to 192.168.1.6:9000:9000
Note 1: Find this in the output, (ignore all ->unable to connect<- errors)
connected to xxx.xxx.x.x:9000
If you see this in the result, just remove the cable from PC and go to Eclipse and run to install the app on the device; that should be it.
Note 2: DISCONNECT OR TO SWITCH WIRELESS MODE OFF: Type the below command. It should say restarting in USB mode - at this stage PC and computer should NOT be connected with a cable:
C:\Users\dell>adb usb
restarting in USB mode
Note 3: Steps to find the IP address of the phone (taken from Stack Overflow)
Find IP address of MY PHONE:
a. Dial *#*#4636#*#* to open the Testing menu.
b. In the Wi-Fi information menu: click Wi-Fi Status
c. Wi-Fi status can be blank for the first time
d. Click Refresh Status
e. In the IPaddr: <<IP ADDRESS OF THE PHONE IS LISTED>>
Note 4: My Phone Wi-Fi connection IP address range typically is as the mentioned IP addresses below,
192.168.1.1
192.168.1.2
192.168.1.3
192.168.1.4
192.168.1.5
192.168.1.6
Note 5: if you get any other sequence of IP addresses which keep getting reassigned to your phone, you can just change the IP address in the w.bat file.
Note 6: This is a brute-force method, which eliminates all manual labor to keep finding IP address and connecting to Eclipse / Wi-Fi.
SUCCESS Note 7: So in short, the regular activity would be something like this:
Step 1. Connect PC and Wi-Fi via a cable
Step 2. Start CMD - to go to Windows DOS prompt
Step 3. Type "w"
Step 4. Find connected command in the output
Step 5. Success, remove cable and start using Eclipse

Best and super easy way to do this is:-
Make a batch file :-
adb devices
adb tcpip 5555
adb connect 192.168.9.120:5555 ( Your phone ip xxx.xxx.x.xxx:5555 )
Place this file into your android sdk platform-tool folder.
Example:- C:\Users\'user_name'\AppData\Local\Android\Sdk\platform-tools
Right click file > sendto > Desktop(create shortcut )
That's it....
Now you just need to connect your phone through USB , then open desktop shortcut and disconnect your phone...

Though there are so many good answers, here is my two cents for the future me :P and for anyone who wants it quick and easy.
For Mac:
connect the device using USB first and make sure debugging is working. Disconnect any other devices and quit emulators.
open terminal and run the following script
adb tcpip 5555
adb connect $(adb shell ifconfig | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | cut -d: -f2):5555
disconnect USB connection and the device should be available for WiFi debugging
Explanation:
adb tcpip 5555 commands the device to start listening for connections on port 5555
adb connect $(_ip_address_fetched_):5555 tells to connect on port 5555 of the _ip_address_fetched_ address
where _ip_address_fetched_ includes following:
adb shell ifconfig getting internet configurations using adb shell
grep "inter " filter any line that starts with inter
grep -v 127.0.0.1 exclude localhost.
At this point, output should be like:
inet addr:###.###.#.### Bcast:###.###.#.### Mask:255.255.255.0
awk '{print $2}' get the second part of the components array, separated by space (I'm using zsh).
The output up to this point is
addr:###.###.#.###
cut -d: -f2 split the string by delimiter : and take second part. It will only take your device IP address

In Device Settigs-> "Developer options" -> "Revoke USB debugging authorizations".
Connect the device via USB and make sure debugging is working.
adb tcpip 5555
adb connect <DEVICE_IP_ADDRESS>:5555
Disconnect USB
adb devices

From search and from some answers i use this method and it work fine
and you must know that tcpip is not always 5555 , you must find it just follow this
you need first to download platform-tools
https://developer.android.com/studio/releases/platform-tools.html
extract platform-tools folder to C drive and run Powershell there (Right click >> PowerShell >> Open here)
#Connect phone with usb cable
PS C:\platform-tools> adb kill-server
PS C:\platform-tools> adb shell ip route > addrs.txt
#this give you your tcpip
* daemon not running; starting now at tcp:5037
* daemon started successfully
PS C:\platform-tools> adb tcpip 5037
restarting in TCP mode port: 5037
#Disconnect phone
#adb connect <phone_ip>:5037
PS C:\platform-tools> adb connect 192.168.43.1:5037
connected to 192.168.43.1:5037
Now you can see your phone in Android studio

>## open command prompt with Run as Administrtor ##
adb connect ipdevice:5037

The best way is using ADBConnect (Eclipse plugin) and ADB Wireless (app for Android device).

For Ubuntu / Linux:
Make sure your device is working for debugging: http://developer.android.com/tools/help/adb.html#Enabling
Go to your sdk folder and find the folder platform-tools
Use ./adb devices to list the connected devices. Make sure it is only one device connected and no emulator running.
Find your device IP address, you can find it in your device:
http://developer.android.com/tools/help/adb.html#wireless, or got adb shell like this: ./adb shell then netcfg. You will see a list of IP addresses. Find wlan0, in my case 192.168.100.3/2.
./adb tcpip 5555
Finally enter ./adb connect <Your device IP Address>:5555 in your terminal. You can now deploy the application to your device over Wi-Fi.

Note :- Android Phone must be rooted and no need of usb cable.
Install wifi adb in android phone from playstore
link :-https://play.google.com/store/apps/details?id=com.ttxapps.wifiadb
For Windows
I am using this technique , which is very easy.
1) download adb :
link : https://www.dropbox.com/s/mcxw0yy3jvydupd/adb-setup-1.4.3.exe?dl=0
2) Run exe :- when you see blue screen press y enter .
3) Now open your wifi adb apk , just grant root permission and must be remember you android phone and system on the same network by wifi or hotspot .
4) Open Wifi adb apk , you will get some ip address like , adb connect 192.168.2.134:5555
Note this ip may be very from system to system , now put this information to your command prompt and hit Enter .
5) Open cmd from anywhere enter adb connect 192.168.2.134:5555 .
6) Finally you successfully connected to adb . it will show message like
connected to 192.168.2.140:5555
For Mac Os
This is the easiest way and will provide automatic updates.
1)Install homebrew
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
2)Install adb
brew cask install android-platform-tools
3)Start using adb
adb devices
4) Open Wifi adb apk , you will get some ip address like , adb connect 192.168.2.134:5555 Note this ip may be very from system to system , now put this information to your terminal and hit Enter .
5) Open terminal in mac os from anywhere enter adb connect 192.168.2.134:5555 .
6) Finally you successfully connected to adb . it will show message like connected to 192.168.2.140:5555
I hope its help you ,Thank You !

If you are a windows user and your android sdk is located at C:\Users\%username%\AppData\Local\Android\Sdk then you can follow this method. If your andoid sdk not located there, replace that path to the below code.
#echo off
"C:\Users\%username%\AppData\Local\Android\Sdk\platform-tools\adb.exe" disconnect
"C:\Users\%username%\AppData\Local\Android\Sdk\platform-tools\adb.exe" shell ip route > %temp%\addrs12321.txt
For /F "UseBackQ Delims==" %%A In ("%temp%\addrs12321.txt") Do Set "lastline=%%A"
FOR %%C IN (%lastline%) DO SET last=%%C
"C:\Users\%username%\AppData\Local\Android\Sdk\platform-tools\adb.exe" tcpip 5555
"C:\Users\%username%\AppData\Local\Android\Sdk\platform-tools\adb.exe" connect %last%:5555 > %temp%\adbresult.txt
set /p result=<%temp%\adbresult.txt
del /f %temp%\addrs12321.txt
echo MSGBOX "%result%" > %temp%\TEMPmessage.vbs
call %temp%\TEMPmessage.vbs
del %temp%\TEMPmessage.vbs /f /q
del %temp%\adbresult.txt /f /q
Step 1.
Turn on usb debugging,
Connect your phone to windows machine
select file transfer in usb options menu in android menu (if found)
Step 2.
copy above code
save as its extension like .bat, eg filename.bat
double click on the file you saved. done
note you can connect any time by running that file while the device
being connected with the pc with usb debugging is turned on.

One imp point probably missed here - once you do a adb remount - the TCP connection is lost hence you have to do a adb connect IP:port once over again

Connect the device via USB and make sure debugging is working. these steps are taken if you already have installed adb and set it's path in environment varialbe
open cmd and type the following
adb tcpip 5555
find the IP address with adb shell ip route
adb connect DEVICE_IP_ADDRESS:5555
Disconnect USB and proceed with wireless debugging.

I wrote a simple script for Windows:
Step 1. Make a batch file with the below commands and call the file wifi_dedug.bat and copy the below contents:
adb tcpip 5555
pause
adb shell "ip addr show wlan0 | grep 'inet ' | cut -d' ' -f6|cut -d/ -f1" > tmpFile
pause
set /p ip= < tmpFile
#echo %ip%
del tmpFile
#echo %ip%
adb connect %ip%
pause
Step 2. connect your device to pc.
Step 3. start batch file (key enter when requested)
Step 4. disconnect your device and deploy/debug via wifi.

1- For this I am considering you have already installed the latest version of Android studio. If not you can download it from here.
2 - You can set the platform tools path in environment variable (optional).
3 - Make sure your device and pc connected to same network.
plug in the data cable from pc to device.
Now, type adb tcpip 5555
remove data cable.
Then type adb connect 192.168.43.95
here 5555 is the port number and 192.168.43.95 is the ip address of the mobile device you can get id address from the mobile settings .
Then go to About device and go to status you can see the ip address of the device.
You can connect multiple device from different ports which can give ease in development.
Or you can go to this link for brief description with screenshots. http://blogssolutions.co.in/connect-your-android-phone-wirelessly-by-adb

Edit August 2021
Google removed it with ArcticFox Beta 03 https://issuetracker.google.com/issues/190411383 but in Android Studio Bumblebee it's still there. It looks like they have to much issues with it, that's why it's just in canary builds
Original post
This Android WiFi ADB plugin doesn't work in 4.1.1 (anymore)
But there is much more simple solution:
If you have an Android 11 (api30) device you should use Android Studio 2020.3.1 (Canary) to connect. It's super easy
Then you go to developer settings and scan QR code. That's it.
You can use connected device in other (older) Android Studio version now as well

Steps for Android Wifi debugging with ADB:
$> adb devices // check all usb debuggable devices connected.
$> adb -d shell // Access device shell.
shell> ifconfig // Check and copy wifi ip-address eg:192.168.1.90
shell> exit // Exit from android device shell.
$> adb tcpip 5000 // open TCP port 5000 (or any available)
$> adb connect 192.168.1.90:5000 // connect to device via wifi ip over specific TCP port.
$> adb devices // you will get debuggabled android device over wifi.
Required: Connect your android device to computer via USB with
developer mode enabled. Also connect your android device and computer
to same wifi router (or use tethering).

Develop Reference

The Android operating system is a mobile operating system that was developed by Google (GOOGL?) to be primarily used for touchscreen devices, cell phones, and tablets.