Android Studio For Beginners: Advanced tools and plugins

A guide to profiling, debugging, and extending your Android Studio applications

Android Studio offers a rich palette of development tools, and it's compatible with many plugins. The first three articles in this series focused on basic tools for building simple mobile apps. Now you'll get acquainted with some of the more advanced tools that are part of Android Studio, along with three plugins you can use to extend Android Studio.

We'll start with Android Device Monitor, Lint, and Android Monitor--three tools you can use to debug, inspect, and profile application code in Android Studio. Then I'll introduce you to plugins ADB Idea, Codota Code Search, and Project Lombok.

Debugging with Android Device Monitor:

Android Device Monitor is an Android SDK tool for debugging failing apps. It provides a graphical user interface for the following SDK tools:

• Dalvik Debug Monitor Server (DDMS): A debugging tool that provides port-forwarding services, screen capture on the device, thread and heap information on the device, logcat, process, radio state information, incoming call and SMS spoofing, location data spoofing, and more.
• Tracer for OpenGL ES: A tool for analyzing OpenGL for embedded systems (ES) code in your Android apps. It lets you capture OpenGL ES commands and frame-by-frame images to help you understand how your graphics commands are being executed.
• Hierarchy Viewer: A graphical viewer for layout view hierarchies (the layout view) and for magnified inspection of the display (the pixel perfect view). This tool can help you debug and optimize your user interface.
• Systrace: A tool for collecting and inspecting traces (timing information across an entire Android device). A trace shows where time and CPU cycles are being spent, displaying what each thread and process is doing at any given time. It also inspects the captured tracing information to highlight problems that it observes (from list item recycling to rendering content) and provide recommendations about how to fix them.
• Traceview: A graphical viewer for execution logs that your app creates via the android.os.Debug class to log tracing information in your code. This tool can help you debug your application and profile its performance.

To launch Android Device Monitor from your command line, execute the monitor program in your Android SDK's tools directory. If you prefer to run the tool from Android Studio, choose Tools > Android > Android Device Monitor.

You might remember from Part 1 that I used Android Studio to launch my W2A example app in the Nexus 4 emulator. I then launched Android Device Monitor from Android Studio. Figure 1 shows the resulting screen.

 

The Devices tab shows all accessible devices, which happens to be the emulated Nexus 4 device in this example. Underneath the highlighted device line is a list of currently visible android.app.Activity subclass objects.

I highlighted the W2A activity object identified by its ca.javajeff.w2apackage name, then clicked Hierarchy View to activate the Hierarchy Viewer tool. Figure 2 shows the result.

 

Hierarchy Viewer displays a multipane user interface. The Tree View pane presents a diagram of the activity's hierarchy of android.view.View subclass objects. The Tree Overview pane offers a smaller map representation of the entire Tree View pane. The Layout View pane (whose contents are not shown in Figure 2) reveals a block representation of the UI. See "Optimizing Your UI" to learn more about the Hierarchy Viewer tool and these panes.

If you attempt to run Hierarchy Viewer with a real (non-emulated) Android device, you could experience the error messages that appear in Figure 3.

 

These messages refer to the view server, which is software running on the device that returns View objects diagrammed by Hierarchy Viewer. Production-build devices return these error messages to strengthen security. You can overcome this problem by using the ViewServer class that was created by Google software engineer Romain Guy.

Inspecting code with Lint

Lint is an Android SDK code-inspection tool for ensuring that code has no structural problems. You can use it to locate issues such as deprecated elements, or API calls that aren't supported by your target API.

Although Lint can be run from the command line, I find it more helpful to run this tool from within Android Studio. Select Analyze > Inspect Code to activate the Specify Inspection Scope dialog box shown in Figure 4. Then select the desired scope (whole project, in this case), and click the OK button to perform the analysis. The results will appear in the Inspection Results window, where they are organized by category.

 

Figure 4. I've decided to inspect the entire project.

As you can see in Figure 5, Lint has spotted a few issues:

 

Figure 5. Lint reports that the androidAnimation field could have been declared private.

Lint also complained about the following:

• A missing contentDescription attribute on the ImageView element in main.xml hampers the app's accessibility.
• The root LinearLayout element in main.xml paints the background white (#ffffff) with a theme that also paints a background (inferred theme is @style/AppTheme). Overdrawing like this can hurt performance.
• The dimens.xml file specifies three-dimensional resources that are not used. Specifying unused resources is inefficient.
• On SDK v23 and up, the app data will be automatically backed up and restored on app install. When you specify an @xml resource that configures which files to backup, consider adding the attribute android:fullBackupContent on the application element in AndroidManifest.xml; otherwise you might face a security issue.
• Support for Google app indexing is missing.
• I stored android0.png, android1.png, and android2.png in drawable, which is intended for density-independent graphics. For a production version of the app, I should have moved them to drawable-mdpi and considered providing higher and lower resolution versions in drawable-ldpi, drawable-hdpi, and drawable-xhdpi. No harm is done in this example, however.
• Lint checked my spelling, noting the reference to javajeff an manifestelement's package attribute, in AndroidManifest.xml.

See "Improve Your Code with Lint" to learn more about using Lint in Android Studio.

Profiling with Android Monitor

Profiling running apps to find performance bottlenecks is an important part of app development. Android Device Monitor's Traceview tool offers some profiling support. Android Monitor offers even more.

Android Monitor is an Android Studio component that helps you profile app performance to optimize, debug, and improve your apps. It lets you monitor the following aspects of apps running on hardware and emulated devices:

• Log messages (system-defined or user-defined)
• Memory, CPU, and GPU usage
• Network traffic (hardware device only)

Android Monitor provides real-time information about your app via various tools. It can capture data as your app runs and store it in a file that you can analyze in various viewers. You can also capture screenshots and videos as your app runs.

You can access Android Monitor via Android Studio's Android Monitor tool window. Select View > Tool Windows > Android Monitor or just press Alt+6:

Figure 6. The logcat pane shows log messages for my Amazon Kindle device.

Figure 6 reveals the Android Monitor tool window, which presents drop-down list boxes that identify the device being monitored (in this case, on my Amazon Kindle Fire device) and the app being debugged on the device. Because ADB integration hasn't been enabled, "No Debuggable Applications" appears in the latter list. Check Tools > Android > Enable ADB Integration to enable ADB integration.

About ADB

The Android Debug Bridge (ADB) is a service that Android Studio uses for debugging Android code on an emulated or USB-accessible device. This service can be used by only one application at a time, and must be enabled before you can use Android Monitor.

After enabling ADB integration, I observed that "No Debuggable Applications" was replaced in the drop-down list with "ca.javajeff.w2a," the package name for the W2A application that was running on my Kindle.

Below the two list boxes are a pair of tabs: logcat and Monitors. The former tab shows logged messages from the device and the latter tab reveals graphics-based memory, CPU, network, and GPU monitors (see Figure 7).

 

Figure 7. The GPU monitor is disabled for Android 4.0.3, which is the Android version that runs on my Kindle.

The memory monitor shown in Figure 7 reveals that the app occupies almost 13 megabytes and its subsequent memory usage is constant, which isn't surprising because the app doesn't make any explicit memory allocations, and the underlying APIs probably don't require much additional memory. The CPU monitor shows only a slight amount of CPU use via a narrow red line about 1 minute into the monitoring. This usage arose from clicking the Animate button several times. No networking activity is displayed because the app isn't making network requests. Finally, the GPU monitor is disabled because I'm running an older version of Android (4.0.3), which doesn't support GPU monitoring.

The left side of the Android Monitor tool window contains a small toolbar with buttons for obtaining a screenshot (the camera icon), recording the screen, obtaining system information (activity manager state, package information, memory usage, memory use over time, and graphics state), terminating the application, and obtaining help. I clicked the camera button and obtained the screenshot shown in Figure 8.

 

Figure 8. Click the camera button on the left side of the Android Monitor tool window to obtain a screenshot.

See "Android Monitor Overview" to learn more about Android Monitor.

Extending Android Studio apps with plugins

Android Studio provides a number of tools for managing application views. You can use Android Studio's built-in Image Asset Studio to manage image assets, Theme Editor to design themes, and Layout Editor to design an activity's layout. If your needs exceed what these tools have to offer, you may be able to fill the gap with a plugin.

Android Studio's plugins manager makes it very easy to find and install plugins. Activate the plugin manager by selecting File > Settings followed by Plugins from the Settings dialog box:

Next, click Browse repositories . . . to activate the Browse Repositories dialog box, which presents a full list of supported plugins:

 

Figure 10. The pane on the right presents detailed information about the selected plugin.

I'll introduce three useful plugins -- ADB Idea, Cordova Code Search, and Project Lombok -- and show you how to install and use them.

ADB Idea

ADB Idea speeds up your day-to-day Android development by providing fast access to commonly used ADB commands, such as starting and uninstalling an app:

 

Figure 11. Click Install to install ADB Idea.

Select ADB Idea in the repository list of plugins and then click the Install button. Android Studio proceeds to download and install the plugin. It then relabels Install to Restart Android Studio. Restarting activates ADB Idea.

Android Studio lets you access ADB Idea from its Tools menu. Select Tools > Android > ADB Idea and choose the appropriate command from the resulting pop-up menu:

Jef

Figure 12. Select the appropriate ADB command from the pop-up menu.

The app must be installed before you can use these commands. For example, I selected ADB Restart App and observed the following messages as well as the restarted app on my Amazon Kindle device.

Figure 13. Each message identifies the app, operation, and device.

Codota Code Search

Use the Codota Code Search plugin to access the Codota search engine, which lets you look through millions of publicly available Java source code snippets (on GitHub and other sites) for solutions to coding problems:

 

Figure 14. Click Install to install Codota Code Search.

To install this plugin, select Codota in the repository list of plugins and then click the Install button. After Android Studio has downloaded and installed the plugin, it will relabel the Install button to Restart the Android Studio. Restarting activates Codota Code Search.

Android Studio lets you access Codota Code Search by right-clicking on Java code in the editor window and selecting the Search Open Source (Codota) menu item (or by pressing Ctrl+K), as shown in Figure 15.

Android Studio responds by displaying the Search Codota dialog box whose text field is blank or populated with the full package name of the Java API type that was right-clicked. Figure 16 shows this dialog box.

Figure 16. Press Enter to initiate the search for Java code snippets related to ImageView. 

Codota Code Search passes the search text to the Codota search engine and presents vertically scrollable search results in a CodotaView tool window.

 

Recall that Figure 15 also showed a Find Usages (Codota) menu item. Clicking this menu item provides you with the ability to semantically search all of your repositories for Java code snippets.

The first time you select this menu item, you will be taken to a web page where you must login via Facebook or some other means. After doing so, you'll receive an authentication token that must be entered in Figure 18's dialog box.

 

Figure 18. Enter the authentication token and click OK.

A second selection of the menu item will take you to a web page for obtaining semantic search (see Figure 19).

 

Figure 19. Click Get semantic search for your code for a free trial.

Click the Get semantic search for your code button and follow the instructions on the resulting page to receive a free trial of the multi-repository semantic search capability.

Project Lombok

Project Lombok aims to reduce the prevalence of some of the worst offenders of boilerplate (the same textual content that's reused repeatedly) by replacing them with a simple set of annotations.

 

Figure 20. Click Install to install Project Lombok.

Select Lombok Plugin in the repository list of plugins and then click the Install button. Android Studio proceeds to download and install the plugin. It then relabels Install to Restart Android Studio. Restarting activates Project Lombok.

To see the usefulness of Project Lombok, suppose we add the following minimal Robot class to the W2A.java source file:

class Robot

{

   private String name;

}

The idea with this class is that we'll store the name of the robot being animated and potentially any other information that might be useful, and display this information as a toast (a small message that appears like a tooltip).

We could add a constructor along with getter/setter methods. However, we can let Project Lombok add this boilerplate for us. To do so, accomplish the following tasks:

1. Right-click on.Robot
2. Select Refactor from the pop-up menu.
3. Select Lombok from the next pop-up menu.
4. Select Default @Data from the next pop-up menu.

You should now observe an annotation @lombok.Data prefixed to the class Robot header. This annotation causes the constructor, getter/setter methods, and more to be auto-generated. You can see all of this boilerplate by repeating the previous steps, except for selecting Delombok instead of Lombok. Source code similar to the following (the domain name will probably be different) is generated by Project Lombok:

class Robot

{

    private String name;




    public Robot() {

    public String getName() {

    }




    }

        return this.name;




    public void setName(String name) {

        this.name = name;

    }




        if (o == this) return true;

    public boolean equals(Object o) {

        final Robot other = (Robot) o;

        if (!(o instanceof Robot)) return false;

        final Object this$name = this.name;

        if (!other.canEqual((Object) this)) return false;

        final Object other$name = other.name;

        return true;

        if (this$name == null ? other$name != null : !this$name.equals(other$name)) return false;

    }




    public int hashCode() {




        final int PRIME = 59;

        int result = 1;

        return other instanceof Robot;

        final Object $name = this.name;

        result = result * PRIME + ($name == null ? 0 : $name.hashCode());

        return result;

    }

}

    protected boolean canEqual(Object other) {

    }

    public String toString() {

        return "ca.javajeff.w2a.Robot(name=" + this.name + ")";

    }

Conclusion

Android Studio is an amazing environment for developing Android apps. In this short series, I've shown you how to obtain and install Android Studio, walked you through a short app-development tutorial, and introduced you to advanced tools and plugins for Android development. I hope you'll consider using Android Studio and its extensible plugin architecture to develop your Android mobile apps.