Connect to Genymotion Android emulator remotely

Even if this might appear as an edge case I know a lot of Android devs using Genymotion emulator for Mac in their daily work, but emulators in general, are RAM eater that slow down the entire system.

Genymotion is an awesome Android emulator, the support is good and the installation is fast and simple: it simply works out of the box!

After experimenting some configurations, I’ve accomplished to run Genymotion on a Windows PC and make it available for connection from my Mac.

The solution has been tested on a local trusted network nevertheless, an SSH tunnel would be preferable.

This solution can be convenient if you don’t want to overload your Mac with the heaviness of the emulator or/and a long test suite takes some time to finish and in the meantime you need to switch to another emulator.

 

Precondition:

  • Mac with Android SDK.
  • Windows with Genymotion installed.

First of all,  go to Genymotion settings > ADB > Select Use custom Android SDK tool and leave it empty, in this way Genymotion will not restart the local ADB when the external ADB will try to connect.

Set Genymotion SDK empty

Now you need to open port 5555 and 5554 to let ADB connects to Genymotion.

On Start, go to Windows System > Control Panel > System and Security > Windows Firewall > Advanced Settings.

ADB remote 5555

Right click on Inbound Rules > New Rule

Select Port

img_20161002_181101

Select TCP

In Specific local ports type 5555

img_20161002_181123

Select Allow the connection

img_20161002_181133

Uncheck Domain and Public if you need this rule for your home network only

img_20161002_181143

Add a name to the rule I’ve called it ADB remote 5555

img_20161002_181236

Now right click on Inbound Rules > New Rule once again and repeat the process for port 5554.

Use the same configurations, just specify 5554 in Specific local ports, and in the end call the rule ADB remote 5554

It’s time to start Genymotion and run our Android emulator.

Take note of the IP address of the emulator, from now on I’ll call it <emulatorIP>.

emulatorip

And now it’s time to forward the incoming connections to the Genymotion emulator.

From the windows machine run command line as administrator: go to Start > type cmd > the first result will be Command Prompt right-click on it and select Run as administrator.

type


netsh interface portproxy add v4tov4 listenport=5555 connectport=5555 connectaddress=<emulatorIP>

and hit return.

type

netsh interface portproxy add v4tov4 listenport=5554 connectport=5554 connectaddress=<emulatorIP>

and hit return.

You can double check you typed correctly running this command

netsh interface portproxy show all

and you should see something like this

screenshot-2016-10-02-18-38-30

Now kill adb on Win

adb kill-server

And take note of the local IP typing

ipconfig | findstr IPv4

I’ll call it <windowsIP>.

screenshot-2016-10-02-18-48-32

Go finally to your Mac and restart the adb.


adb kill-server
adb start-server

And connect to Genymotion by typing the IP of the Windows PC

adb connect <windowsIP>:5555

screenshot-2016-10-02-18-51-05

 

 

This is the solution I found without using any external software for SSH tunnel or PuTTy, if you want to explore more solutions you can check these posts on StackOverflow

 

Android advanced ADB Show Layout Bounds

Show layout bounds can be activated by ADB and is a really helpful option especially when it comes to polish UI and check everything is alright.

Layout Bounds

This option can be activated by command line exiting the app, setting the property and starting the app again.

 adb shell am force-stop com.company.appname ; adb shell setprop debug.layout true ; adb shell am start com.company.appname 

 

An even easier way to achieve this is using a Groovy script available here

https://github.com/dhelleberg/android-scripts

Commands are easy and in real-time:

  • devtools.groovy overdraw on/off (it will show/hide overdraw in current UI)
  • devtools.groovy layout on/off (it will show/hide layout bounds)
  • devtools.groovy gfx on/off (it will show/hide gpu rendering)

 

There is also a youtube video with a quick demonstration:

https://www.youtube.com/watch?v=GOJaOsJ0BJs

 

The second file in the project is another Groovy script to help connect your device with adb in Wifi mode.

(Precondition: android device and your Mac/PC must share the same WiFi Network)

These are the commands without using adbwifi.groovy script to achieve the same.

Connect the device via USB and from terminal type

 adb shell ip -f inet addr show wlan0 

Take note of the IP address of the device

 adb tcpip 5555 
 adb connect DEVICEIP:5555 

Disconnect the USB cable, the device should be connected via WiFi

Try to type

 adb devices 

Outcome will be

 List of devices attached
 DEVICEIP:5556 device

Using the script is much easier, simply connect your phone via USB (in best case with WiFi switched on), run adbwifi.groovy and wait until it tells you to disconnect and press enter.

 

Remember to install Groovy if you decide to use the script above.

Sparse Array vs HashMap

This is the answer I gave for a StackOverflow question.
I’d like to report it here for the records.

 

Sparse arrays can be used to replace hash maps when the key is a primitive type. There are some variants for different key/value type even though not all them are publicly available.

Benefits are:

  • Allocation-free
  • No boxing

Drawbacks:

  • Generally slower, not indicated for large collections
  • They won’t work in non-android project

HashMap can be replaced by the followings:

    SparseArray          <Integer,Object>
    SparseBooleanArray   <Integer, Boolean>
    SparseIntArray       <Integer, Integer>
    SparseLongArray      <Integer, Long>
    LongSparseArray      <Long, Object>
    LongSparseLongArray  <Long, Long>   //this is not a public class                                 
                                        //but can be copied from  Android source code 

In terms of memory here is an example of SparseIntArray vs HashMap for 1000 elements

SparseIntArray:

class SparseIntArray {
int[] keys;
int[] values;
int size;
}

Class = 12 + 3 * 4 = 24 bytes
Array = 20 + 1000 * 4 = 4024 bytes
Total = 8,072 bytes

HashMap:

class HashMap<K, V> { 
Entry<K, V>[] table;
Entry<K, V> forNull;
int size;
int modCount;
int threshold;
Set<K> keys
Set<Entry<K, V>> entries;
Collection<V> values;
} 

Class = 12 + 8 * 4 = 48 bytes
Entry = 32 + 16 + 16 = 64 bytes
Array = 20 + 1000 * 64 = 64024 bytes
Total = 64,136 bytes

Source: Android Memories by Romain Guy from slide 90.

The numbers above are the amount of memory (in bytes) allocated on heap by JVM. They may vary depending on the specific JVM used.

java.lang.instrument package contains some helpful methods for advanced operation like checking the size of an object with getObjectSize(Object objectToSize).

Extra info are available from official Oracle documentation

Class = 12 byte + (n instance variables) * 4 byte
Array = 20 byte + (n elements) * (element size)
Entry = 32 byte + (1st element size) + (2ns elements size)

Android ADB commands to locate Activities

Sometimes during debug or bug fixing I need to locate the activities in the source code.

The Android Debug Bridge provides some commands to help us.

Make sure your device is USB connected and the activity to locate is in foreground.

From terminal:

 adb shell dumpsys activity activities | grep mFocusedActivity 

It will print out something like this:

mFocusedActivity: ActivityRecord{44ff17b u0 com.youpackagename/.ActivityName t14533}

It’s so simple!
I realized I used it so often I created a script.

 echo "adb shell dumpsys activity activities | grep mFocusedActivity" >> locator.sh
chmod a+x locator.sh 

From now on, every time you need to locate the activity in the source code just type from terminal ./locator.sh