Frequently asked questions

We strive to make our product intuitive to use and we hope you don't have to read an instruction manual. But in case you're ever stuck, here are some basics about how to use little eye.
First, please refer to the blog post here for a more visual description of how to get started.

Here are some details:
  1. Start the 'littleeye' executable from under 'little eye' directory in the directory where you have installed the product.
  2. Connect your Android device to your computer through a USB cable.
  3. Little Eye will connect to the device, bring up the Applications view, and show you the device details as well as all the installed apps. If this does not work, ensure that you have followed the steps mentioned in the "prerequisites" section below.
  4. Double click on the icon of your app (or your competitor's app, if you like :-)).
  5. Little Eye will open the Details view and bring up the power consumption graph by default.
  6. Start using your app on your device, similar to how a user would. You should try to cover all the ways (activities, menus etc) your app is expected to be used.
  7. When you're done using the app, click the Stop button on Little Eye desktop tool or select the 'little eye' notification icon on the device and click 'Stop'.
  8. Little Eye will bring up the screen capture of the app on the right pane, and the graph of power consumption in the main pane. The bottom pane is a Time Line view which you can use to zoom in or out of the graph in the main view.
  9. Repeat steps 5 to 9 multiple times, to cover all your app's use cases.
  10. It is better to have multiple runs of each feature to improve the accuracy of measurement.
  11. Click on the "Generate Report" icon . This will open the "App Report" view and show you the power consumption details of your app, and a breakdown of power consumed by your app by components. Selecting the Data Report radio button on the left pane will show you a report of your app's wireless data consumption broken down by state. Selecting the Memory Report radio button will show you a report of your app's memory consumption and garbage collection details.
  12. Note that its recommended that the Power Report is used with tests where screen capture is turned off, as the screen capture could have a non-negligible impact on the results of the app. The screen recording is most useful when performing analysis-type activities.
In case the above did not satisfy your needs, do shout at us at support@littleeye.co, and we will certainly work on improving the quality of our documentation.
  1. You need the Android SDK to use Little Eye. If you don't have it already, you can download it from here. We have tested Little Eye with revision 20, so it would be best if you have the same or higher versions.
  2. If you are using a version which does not ship with a JRE, you need to have JRE 6 or later preinstalled on your PC or Mac.
  3. Ensure that your test phone is set to allow USB debugging.
    • On Android versions lesser than 4.x, you can do this by going to "Settings > Applications > Development".
    • On Android 4.0.x & 4.1.x, this setting is usually found in "Settings > Developer options".
    • On devices running Android 4.2, developer options are hidden by default. You can reveal the developer options by tapping 7 times on "Settings > About phone > Build number" on any compatible Android device. (Yes, we know - we're scratching our heads about the "7 times" thing too!)
  4. To ensure that USB debugging is correctly enabled, connect your phone to the USB port of your compouter and ensure that Android detects and shows a notification icon with the message "USB debugging enabled/connected". If you are using Windows, you may need to ensure that you are connecting as a "Camera (PTP)" rather than as a "Media Device (MTP)".
  5. If the above steps do not enable "USB debugging" on your phone, and especially on Windows systems, you may need to install additional drivers depending the mobile device you’re using. Please check out https://developer.android.com/tools/extras/oem-usb.html for details regarding where and how to download/install the drivers for your respective devices.
  6. This release of Little Eye was tested with JRE 6
These are the known issues in Little Eye today:
  • On Mac OS X, Little Eye does not show screen recording with Java 7. Please use Java 6 instead. For instructions to set up Little Eye to use Java 6, please refer this support page
  • On some devices, if the app changes the brightness, Little Eye may not capture the brightness correctly and use the value from the device settings.
  • If there is not enough free space on the device, Little Eye’s native component may not be installed correctly. This will cause the screen recording to be disabled, and also a few other features will not work.
  • Android 4.3 Jelly Bean is not currently supported. You will not be able to get the screenshots or the logs at the moment.
  • While calculating the wireless data transfer, Little Eye does not currently track UDP packets. You may get incorrect values if your App is using UDP.
  • While your app is running in foreground (or perceptible) and any other app uses Android Mediaserver, the Mediaserver consumption will be (wrongly) attributed to your app.
  • Occasionally, you may see the Device Total being lower than the App Total at a particular time. This is caused by Android system may be updating the values wrt System and App related data at slightly different times. If this happens, typically, the next second will have the correction for it in the Device Total.
  • Currently the power computation takes into account only five subsystems CPU, Wifi,Display, 3G and GPS. The app’s power consumption is a factor of the hardware components it uses, and Little Eye currently tracks consumption caused by these subsystems only. Support for other components will be added in future releases.
  • The synchronization between the screen-captured video playback on the left and the performance graph on the right may be off by one or two seconds occasionally. However, if you ever observe large deviations (more than 4 seconds), kindly report it.
  • Little Eye supports devices running Android version 2.2 and above.
  • If for any reason the monitoring component on the phone dies, it will get autorestarted. But the video after that point might not get captured. Currently the point of failure is not obvious.
  • The Little Eye power score of an app may be affected by the screen capture activity. Hence the score may be different, depending on whether screen capture is enabled or disabled. It is recommended that the tests run with screen capture turned off be used for the power score computation. Screen capture can be disabled from Preferences.
  • In case of GUI Little Eye, if more than one devices are connected to the PC, only the “first” device will be detected and used. The “first” device is as detected by ADB and so we don’t have control over which is the “first” device.
  • Little Eye currently doesn't work with a few Alcatel devices (like the Alcatel OT-991/One Touch).

Little Eye connects to your device via USB, so first check if the USB port is connected and the device's "USB debugging" setting is enabled (This can usually be found under developer options on your phone's settings page).

Little Eye uses ADB to talk to your phone. If you are on Windows, you will need to install the device's drivers to allow ADB to talk to your device. The drivers can usually be found on your phone manufacturer's website. More information is available here.

If you are using Windows, you may need to ensure that you are connecting as a "Camera (PTP)" rather than as a "Media Device (MTP)".

Please report every bug you observe to support@littleeye.co. Also please give us your bouquets and brickbats to 42@littleeye.co

Troubleshooting & Help

An asterisk indicates that this run is not saved and needs to be saved. If you are using version 1.0.0 of Little Eye, then typically all the runs are automatically saved (and the asterisk does not appear). But if you open a run created by an older version of Little Eye, then Little Eye will automatically convert it into the newer format and tries to save it. In case it could not overwrite the file, it will give you a prompt that it is unable to save the file, and it shows an asterisk before the title of the run.
If you are trying to debug memory leaks, you would need to take heap dumps. It is necessary that the heap dumps be taken at an appropriate point of analysis. More often than not, it means a point where the app is hitting a high in its memory usage. Configured Heap dumps enable you to automatically get heap dumps at those points in the app.You could specify the memory size at which the heap dump should be taken.

Sometimes you may want to have more than one heap dump, so that you can compare and find out the memory that is growing. In this case, you could get multiple heap dumps generated at a specified interval.

Once you get this heap dumps, you can open and analyze them in tools like Eclipse Memory Analyzer Tool (MAT).
Little Eye can profile system apps. This is enabled in version 1.0.0.

To make system apps show up in your Applications view, open Preferences > Little Eye and enable "Show System Apps" by clicking the check box.
Here are explanation of various components that Little Eye shows in its Memory graph:
  • PSS (propotionate set size) is a statistics that Android uses to determine if its time to kill your process (esp when its running in the background). 'PSS' is memory that is owned by your app exclusively (size of private memory blocks that is not shared) + (memory that is shared with other processes)/(# of processes that is sharing it). Basically it gives a more truer sense of the memory that a given process owns. If your app is killed in the background, the PSS is what it would have used to determine if it should be killed.
  • App Native is the native memory that your app is using. This includes the memory that the dalvik vm allocates for its functioning.
  • App Dalvik is the amount of dalvik memory that dalvik vm allocates for your app to run.
  • App Total is the sum of dalvik and native memory. This is represented by the shaded area in the graph.
  • Threshold (or Dalvik Limit) is the maximum dalvik memory that the vm will allocate for your app. This indicated by the straight, horizontal, dotted line on your graph. If your app uses more memory than this, your app is likely to get an OOME (Out of Memory Error).
Heap dump contains a snapshot of all the objects that are alive in the memory at the point the heap dump is taken. Heap dumps are useful to analyze an app's memory consumption and identify memory leaks.

Little Eye helps you to easily capture an heap dump. It also converts into a format which can be used by popular tools like MAT (Eclipse Memory Analyzer).

While you are monitoring your app, if you see that there is lot of growth in memory and you want to understand the reasons behind it, you could just take an heap dump from the 'Dump Heap' menu item. You could also configure to dump the heaps automatically whenever the memory reaches a threshold using 'Configure Repeating Heap Dumps'. If you have multiple heap dumps, you can load both the heap dumps in MAT and find out the objects and alive at two points of your application.
Yes, Little Eye monitors all the background processes and services. The data that it shows is the accumulated data of all the processes that runs as part of your app uid.
Little Eye has multiple components. There is a component that is installed on your phone/tablet. This component periodically collects the usage statistics of various components like CPU, Wifi and Screen. This data is then sent to the Little Eye component on the desktop. The desktop component runs these statistics through the power model model of a device (currently a Nexus One phone) and thus calculates the battery consumption by various components.
On the right side of the graph, you would see the legends of the graph. Clicking on the 'System Total' will stop showing the system total.
Custom events are special events that you can log into your Logcat stream that Little Eye can parse and show on the events view while you are monitoring your App. Little Eye allows you to inject custom events using the android.util.Log class. To allow Little Eye to parse the custom events, you have to use the tags: LEStartEvent and LEEndEvent. Here's an example:
Log.i("LEStartEvent", "Page load started");
... process...
Log.i("LEEndEvent", "Page load finished");
			
These two events will then appear on the events view while you are monitoring your app using Little Eye. You can customize the tag names in the preferences setting of Little Eye (Window -> Preferences)
Little Eye was developed with use cases for developers and testers as part of their 'pre-production testing' use-cases and we felt a desktop solution gives much more rich fidelity of the data. But we understand that an standalone app will also provide flexibility for other use-cases, but unfortunately we don't have support for it currently.

Note that we support what is called as "Limited untethered mode" in our product, where you can start the monitoring activity from the desktop (with the USB connected) and then disconnect the USB for about 10-20 minutes and roam around.

Another alternative is to connect to ADB via Wifi. Refer to this blog for being able to use the Wifi instead of USB for using Little Eye.

Hope this helps. If not and if you still need an app, one alternative is "PowerTutor"

The 'custom events' feature in Little Eye would help you capture times of various response times with your Android app. Here is a blog post that can be used your quick reference on how to use custom events.

Little Eye was built to enable mobile app developers & testers build apps that are not just fast, but also reliable, dependable, resource-light and well behaved among other things. Here is an SD times article on the need for broader performance metrics for mobile apps.

Here are some blog posts that should help you get more out of your full-featured Little Eye trial: Simple Tests
Memory Leaks
GPS
Power Bugs
Power Optimization
Jenkins
We have been working on improving our drill downs and developer debugging capabilities and the latest release that is now available from our website, includes features such as threads view, call stacks, app instrumentation that would allow you to better understand the resource consumption trends of the app being monitored by Little Eye.

We also have other features such as source code/IDE integration in our product roadmap and you can expect to see these in our future releases.
Currently, we only support pre-launch performance monitoring/analysis of Android apps. We are working on building similar tools for iOS and Windows Mobile but we don't have anything that you can try today.
We have debated the recording quality a few times internally and for now we are still focusing on keeping the tool as lightweight as possible. Our current capture rate is 3 fps & we scale down the resolution significantly. So, this can certainly be improved upon in the future based on customer requests / feedback.
Here is a blog entry describing our power model, in case you have not already seen it:

The accuracy of the absolute power measurements (like mA, % battery drain etc.) would tend to be low (60-70%) depending on how different the hardware is from the one of the Nexus One or Galaxy Nexus. However, the relative power consumption trends or power scores of your app across multiple runs / devices would still very reliable and this should help you identify, debug & fix power issues in your app on any device.
We believe that the performance of an app has two primary aspects - user responsiveness and resource consumption. There is an interdependence between the two, but it may not always be obvious most of the time. Many a time the user responsiveness has a root cause in resource consumption. As of now, Little Eye (and by extension our performance score) focuses mostly on resource consumption. However, we are working on ways to provide frame rate statistics to help identify dropped frames.
At the moment, Little Eye power measurement trends do not account for GPU usage of your app. However, we are starting to work with Qualcomm & Nvidia in order to be able to do this as at the moment some of the critical GPU related system information is not reliably available to us for direct consumption or use in computations.
Please provide the following details of the charge for us to investigate this:
  1. Email address associated with this charge
  2. What does the charge appear as in your card statement eg: Walmart
  3. What is the date & amount of the charge?
  4. Have you raised a dispute on the charge with your credit card company? If so, please provide a reference number for this dispute with the name and contact number for your credit card company.
At the moment, Little Eye does not support emulators. Emulators tend not to return accurate data. Some metrics like power consumption, battery state, CPU frequencies are unreliable on the emulators, so we explicitly don't support them.
Little Eye supports all Android version above 2.3. However, the screen capture feature may be disabled for some of the devices running Android 4.3 due to a bug in Android's Surface Flinger code. We have filed this bug with Google and are also exploring ways to work around this issue until the bug is fixed by Google. Please also note that this issues tends to get triggered in the newer device models and some of the older models running 4.3 may work fine.
On Linux, when you try to start Little Eye, it does not start and gives a JVM error - something like this:
JVM terminated. Exit code=13
/usr/bin/java
-jar /home/layman/.littleeye-dist//plugins/org.eclipse.equinox.launcher_1.3.0.v20120522-1813.jar
-os linux
-ws gtk
-arch x86
-showsplash
-launcher /home/layman/.littleeye-dist/littleeye
-name Littleeye
--launcher.library /home/layman/.littleeye-dist//plugins/org.eclipse.equinox.launcher.gtk.linux.x86_1.1.200.v20120522-1813/eclipse_1502.so
-startup /home/layman/.littleeye-dist//plugins/org.eclipse.equinox.launcher_1.3.0.v20120522-1813.jar
--launcher.overrideVmargs
-exitdata 13000e
-vm /usr/bin/java
-vmargs
-jar /home/layman/.littleeye-dist//plugins/org.eclipse.equinox.launcher_1.3.0.v20120522-1813.jar 
The most likely cause of this error is that JVM architecture and Little Eye architecture different ie., you are using a 32-bit JVM with 64-bit Little Eye or vice versa. You can fix this by adding the path of appropriate JVM to littleeye.ini file in the installation directory (typically the directory .littleeye-dist in your home directory).
For Little Eye to communicate with your mobile device, the device needs to have USB debugging enabled. To confirm, check the notifications on your device. If it is connected to USB debugger, you would typically see a notification about USB debugging connected.
On some versions of Linux, you may see an error from GTK that looks like:
LIBDBUSMENU-GTK-CRITICAL **: watch_submenu: assertion `GTK_IS_MENU_SHELL(menu)' failed
This is caused by an issue in running Eclipse / SWT applications on Ubuntu. This error is harmless and you can ignore it. If you would like to workaround, you can set the environment variable UBUNTU_MENUPROXY to 0 to disable this error.
Little Eye needs to connect to its servers for generating a trial license. Please ensure that
  1. Your computer is connected to the internet.
  2. If you use a proxy to connect to the internet, please enter its details in Preferences > Little Eye > Internet Proxy and enter the details.
Little Eye on Mac, if running on java 7, has a problem showing the screen capture. The alternative is to use Java 6. Here are the instructions to setup Java 6 to be used by Little Eye.
  1. Ensure that Java 6 is installed on your machine: Runing the following command in the terminal shows the list of JRE's installed on your machine. %/usr/libexec/java_home -V If Java 6 is not installed, you could install it from here
  2. Open the file littleeye.ini located in /littleeye.app/Contents/MacOS. Add the following two lines in the beginning of the line -vm /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/bin/java
If you still have the problems, please contact us at support@littleeye.co.
If you are behind a proxy, you can configure your proxy settings in Little Eye by going to Window -> Preferences.
Here, you can set the proxy parameters:
  • Proxy Protocol is http or https
  • Proxy Host is the server name or IP address
  • Proxy Port is the port on which the proxy server is running
  • You can also optionally configure your username and password, if your proxy needs authentication.
Once you have your proxy set, you can sign up for a trial license or register an activation code by going to Help -> Enter Activation Code...