Android Studio

The Android Studio menu lists the main menu items, which provide access to updates and window management, along with the hide, quit, and show options, as shown in Figure 4.1.

The most important item in this menu is Preferences (Settings in Windows and Linux), which you may need to access many times to configure Android Studio.

The Preferences window gives you access to all the detailed Android Studio configurations: Appearance & Behavior, Keymap, Editor, Plugins, Version Control, Build, Execution, Deployment, Languages & Frameworks, and Tools, as shown in Figure 4.2.

File

The File menu gives you access to file operations such as saving a file, adding a new file, selecting templates, opening existing files, and closing a project folder, as shown in Figure 4.3. It also includes file operations including setting the style of files in Android Studio, exporting any file as HTML, and setting Line Separators for the corresponding operating system to make a file readable by other operating systems.

In addition to the File menu giving access to file settings, it also has a New submenu (see Figure 4.4) with actions to create a new project and to import a project from local sources or from a version control system. Adding and importing a new module is also done from the New menu. Finally, can add a new file, directory, C++ Class, C/C++ Source or Header file with the actions defined in the New menu.

In addition to file operations, you can access the Project Structure window shown in Figure 4.5 from the File menu. The Project Structure window includes options for configuring the project, such as the Android SDK, NDK, and Java path, and developer services provided by Google, such as Google Sign-In authentication service configurations.

Edit

The Edit menu includes text operations such as copy, paste, and cut functionality, and so on, as shown in Figure 4.6. The following list provides a quick reference to the operations for copying and pasting during coding.

• Copy Path—Copies the full path of a recently opened file
• Copy as Plain Text—Copies any text without formatting.
• Copy Reference—Copies the reference to the file in the system. For example, if you select Copy Reference for a Java file, it will copy only the name of the Java class.
• Paste from History—Lists previously copied texts and so you can select from the history to paste them.
• Paste Simple—Pastes the last copied text without formatting.

The Edit menu options are not limited to basic copy and paste; there are more complex functions for searching and selecting under the Find submenu such as Find in Path and Replace in Path, Find, Duplicate Line, and Join Lines (see Figure 4.7).

There is also a Macros submenu that is used to save keystrokes to a macro for reuse.

In summary, this menu provides access to text editor functions available in most text editors. These items simplify the process of writing code and editing files. We recommend that you become familiar with shortcuts listed in the menu to make these functions easier to use.

View

The View menu, shown in Figure 4.8, provides easy access to functions for working with windows, configuring the editor spacing, adding line numbers, accessing the compare tool, and other similar functionalities of Android Studio.

Through the View menu, you can change the current view of Android Studio as well as enable or disable the Tool buttons, Toolbar, Status Bar, and Navigation Bar. In summary, this menu will help you change or customize the view of Android Studio's windows.

Navigate

The Navigate menu, shown in Figure 4.9, lists the actions you can take to navigate between files in the current open project. Practice with the navigation functions will make it easy to handle large projects with many files, classes, and long files.

You can add bookmarks to file lines so you can directly jump there during development, or navigate to a superclass by pressing Command+U on Mac or Ctrl+U in Windows. As shown in Figure 4.10, you can also see all the implementations of a superclass to enable you to navigate to a subclass.

All functionality provided in the Navigation menu will help you manage and find related files, folders, classes, declarations, and inherited classes easily and to understand the architecture of the software and avoid wasting time looking for a superclass's definition. Developing familiarity with these functions will definitely increase how much you like the IDE.

Code

The Code menu, shown in Figure 4.11, provides access to functions to easily generate code snippets, arrange code lines, add block comments, access Live Templates, add getters and setters, and similar activities.

Most of the functions are usable if you are in a Java file, but not if you are not in a Java file.

Let's look at two of this menu's options. Click Override Methods (Control+O on Mac or Ctrl+O in Windows) while in a Java class to open a new window that shows the methods you can override from inherited classes. If you want to re-indent your code, click the Auto-Indent Lines option (Control+Option+I on Mac or Ctrl+Alt+I in Windows).

Familiarizing yourself with the shortcuts on this menu will enable you to efficiently develop your code. For example, if you just inherited an interface, navigate to the Code menu and press the indicated shortcut for the Implement Methods option to see the list of methods you should implement for the current class. This saves the time that would otherwise be spent on documentation or navigating between superclasses.

Analyze

Analyzing your code with Android Studio is fun. Analysis gives you many insights into what to do next to improve the quality and stability of your code. Figure 4.12 shows the Analyze menu.

From the Analyze menu, let's inspect the UniversalMusicPlayer's MediaNotificationManager.java file. With the file open, select Inspect Code. This will open a new window at the bottom of the main editor and project pane to show the code maturity, possible bugs, and spelling and declaration suggestions, as you can see in Figure 4.13.

Refactor

Refactor menu tools provide developers easy access to certain refactoring operations, as shown in Figure 4.14.

To start refactoring, select a piece of the code in the file and then press Control+T on Mac or Ctrl+Alt+Shift+T in Windows to display the refactoring options, as shown in Figure 4.15.

Refactoring a large project might be difficult, but Android Studio's refactoring tools, when appropriate for your purpose, leads you to the right standards-compliant approach. The section “Code Refactoring with Android Studio” later in this chapter provides additional information on refactoring.

Build

The Build menu lists the commands to build the application and related configuration functions. These commands include APK generation of Android applications, signing APK files, editing dependencies, configuring build types, and selecting SDK versions, as you can see in Figure 4.16.

The Clean Project and Rebuild Project options are straightforward. They start clean and build functions as in other IDEs. Other options in this menu are mostly related to the output APK file configuration. We will cover these in greater detail in the APK generation and signing APK sections, later in the chapter.

Run

The Run menu provides options for managing application processing such as running in debug mode or not, or accessing APK release configuration while running/debugging the application.

You can see all the shortcuts related to running and debugging your application from the menu. It will give you fast access during debugging. If your application is not in debugging mode, most of the menu items are disabled.

Tools

The Tools menu provides some tools not directly related to Android application development. You can create tasks to follow up with your development, generate JavaDoc, and create new scratch files to test some code snippets directly inside the project instead of creating a new Java or Android project, This menu is shown in Figure 4.17.

Finally, from the Tools menu you can launch the Android SDK Manager, AVD Manager, and Android Device Monitor.

Version Control System

The VCS (Version Control System) menu, shown in Figure 4.18, gives access to tools related to source control management. Android Studio helps developers to locally control the source code history, integrate with a selected version control system, and check out the source code from the remote repository.

Chapter 9 explores the use of Android Studio's version control system in greater detail.

Window and Help Menu

The Window menu helps you manage tabs and windows, including the management of each tool window's visibility type, such as docked, floating, and so on. You can also navigate between Android Studio windows if multiple Android Studio windows are open.

The Help menu gives you access to the Android Studio documentation, where you can easily search for an action. If you want to look for the refactor or block comment shortcut, go to the Help menu and click Find Action (Shift+Command+A on Mac or Ctrl+Shift+A in Windows) to search for a specific action in Android Studio.

Messages

The Messages tool, shown in Figure 4.24, is available by default; it will get active when there is a need to show messages to the developer such as errors, warnings, information, notes, and generic information about the build process, as shown in Figure 4.24.

In Figure 4.24, the Messages window shows the output messages from a Gradle build. If you opened the sample application as suggested in the previous section, it may automatically start the build process and show the output from the Messages window.

The Messages tool helps you follow what other tools are doing. In showing the errors, information, and warnings for the process in the window, the tool reveals what is going on in the background. Otherwise, it would be hard to follow up with ongoing processes.

The Messages tool has additional features to export messages in a text file to share with your team, get help, and resolve issues quickly.

The buttons on the left-hand side of the window let you easily navigate between messages. That can be difficult because there will often be more than the ten lines of messages shown in Figure 4.24; you may encounter thousands of lines. The buttons help you to expand or filter the list, and even go to the source of the error when necessary.

Android Studio Project Structure

Android Studio's Project tool is responsible for listing your project's files. It helps you directly browse the files and folders of your project in a tree structure from within Android Studio.

Android view shows files and folders grouped under Android modules and scripts. Each Android Module's Java source, test, manifest, and resource files will be grouped under the module name. Scripts will be under a different group named Gradle Scripts as shown in Figure 4.25.

The file and folder view options shown in Figure 4.25 are useful for creating a custom view for developers working on separate parts of the project because they enable the developer to focus on the context of his or her area of development. Compared to Eclipse IDE, this feature helps you filter to a simplified view of the project instead of forcing you to see all the files; it eliminates most auto-generated files, which you generally don't need to view. You can interpret this as a simple separation of concerns by Android Studio.

The view options change the file and folder listings as follows:

• Project—Lists all files and folders located in the Android application's project folder, which select while you are populating the project. This view option also lists the external libraries used in the project.
• Packages—Lists the files with package classification. XML files, menu files, layout files, drawable files, and Java source files are classified under a list of folders to ease direct access to the package you are working on.
• Scratches—Shows the list of scratch files created and used.
• Android —Shows only an application's related files. Applications are shown as modules—mobile, wear, library, and so on. This view enables fast access to your application.
• Project Files—Presents the build, license, and source control management–related project files. These include the.gitignore and local.properties files, and the .google and .ide folders.
• Problems—Shows only files with problems. To test this feature, delete a semicolon from a line in a Java file. The file will then be shown in this view to direct you to the problem.
• Production—Shows the folders related to the production of the application, such as the build output folder and the configuration folder, as well as the final source files which affect the production version of the application.
• Tests—Shows test-related results.
• Android Instrumentation Tests—Presents the Android Instrumentation test files.

Favorites

The Favorites tool, shown in Figure 4.26, provides fast access to your favorite folders and files, to bookmarked locations in files, and to toggled break points in the project.

Adding a favorite is easy, just right-click a file in Project view or right-click an opened file's tab in the editor; then click Add to Favorites. The first time you do this, you will see only one group to add your file to in the favorites list. If you are following our example, it is UniversalMusicPlayer. You can also generate your own favorite group to classify your favorites under different lists.

Adding a new bookmark is also easy: Press F3 or F11 in Windows or use the Navigate menu's Bookmark option. A bookmark will be added to a line you select and the bookmark will be listed in the Bookmarks list in the Favorites window.

You can navigate between bookmarks by selecting the Show Bookmarks option from the Navigate ⇨ Bookmarks menu, or just press Command+F3 on Mac or Shift+F11 in Windows.

Breakpoints are added as favorites in the same way as Bookmarks. After you add a breakpoint in a file, it is listed in the Favorites window. In Figure 4.26, you can see that we added two bookmarks and one breakpoint to the sample project randomly.

Android Monitor

While developing your application, you will use the Android Monitor extensively (see Figure 4.27). With this tool, you can start and stop tools that monitor the use of resources on the Android device. The Android Monitor monitors the application during debugging or when it's running on the device. Processes monitored include GPU, memory, CPU, and network utilization.

The Android Monitor includes Android's logger tool, the Logcat utility. Figure 4.27 shows a typical log output.

Chapter 8 covers Android Monitor tools in detail.

Structure

The Structure window lists the components of structured files such as Java, XML, and Gradle. Using this view, you can see all the methods, fields, and tags of XML files, and inherited members of a Java class. Instead of scrolling up and down, you can directly access a member of the file and work on it.

In our sample application, let's open a more complex class named MediaNotificationManager, placed under java sources, inside the com.example.android.uamp package. MediaNotificationManager inherits members from BroadcastReceiver to be able to list the details of the Java class, as shown in Figure 4.28.

In this window you can see the members that are inherited from BroadcastReceiver or Java's object class itself. Constant (final) or static members are identified by a lock symbol. In addition, (m) indicates the methods, (f) indicates the fields of the class, (C) shows the classes, (I) shows the interfaces, (p) indicates properties of class. This helps you understand any Java classes' design and architecture and assists with analyzing existing code. For example if you are navigating in a large project to understand the design of the classes, you can see the structures easily to understand how they were created.

You can also open XML files to see the details and relationship of the tags to each other.

Android Model

The Android Model view provides an easy access to an Android application member's initial values. These values do not contain the Java class members; the model includes the project build members, folder locations, compilation configurations, build type initializations, APK signing options, and so on.

The list is very long so it is hard to remember all the required fields to configure. Having this tool, which lets you see and review all the configuration's constant values, is very valuable. As shown in Figure 4.29, you can see all initializations.

This example shows only a single mobile application; if you have multiple modules in your project, the tool will show related configuration parameter values.

Gradle and Gradle Console

The Gradle and Gradle Console window tools show Gradle tasks in your project. When you open the Gradle window, you can execute any task independently and remove or add a new Gradle task to your project.

Gradle Console connects to Gradle builds, and this window shows whether the Gradle build tasks are successful or not. It is a simple console that shows only the output text.

We don't do any more changes to the default Gradle configuration and tasks in this chapter, because we will cover Gradle and Gradle Console in more detail in Chapter 6, which discusses the Gradle build system.

Run

The Run window is enabled when you run the application (as shown in Chapter 3) on a remote Android device or emulator. It lists the process and commands launched during the run phase such as APK installation on the device and the process ID of the application.

As shown in Figure 4.30, we launched the UniversalMusicPlayer application from our development machine to a remote Android phone.

This tool also gives you the ability to stop, run, or re-run the application with the buttons shown at the left.

Debug

The Debug window is inactive by default and activated when you start debugging your application. After you click the debug button at the top of the Android Studio window or press Control+D on Mac or Shift+F9 in Windows to launch the application in debug mode, the Debug window appears at the bottom, as shown in Figure 4.31.

In short, this window enables you to run an application step by step and see the variables. It also provides all required debugging ability to analyze and find the vulnerabilities of the application. (Detailed debugging properties are investigated in Chapter 8.)

Event Logs

The Event Logs tool prints events such as the Gradle build's start date and when you started an application's run session. It also prints errors or warnings that have occurred. The best feature of the Event Log tool is that it notifies users about these events and their start and finish times. Event logs help you understand the history of your development.

Terminal

The Terminal allows you to interact with the operating system's shell. It helps you do the required configuration and file manipulation, such as deleting, moving, and renaming files and folders in the current project directory without changing your context.

There are tools provided with Android SDK that do not have GUI support, so they are accessed via the command line.

As shown in Figure 4.32, when you open the Terminal window, you enter the current user's project's root folder.

Code Assist

The killer feature of Android Studio editors is code completion assist. This feature has been a standard in similar IDEs such as Eclipse, Visual Studio, and NetBeans; however, Android Studio brings the assist to a completely new level.

For basic code completion, you can use Control+space on Mac or Ctrl+space in Windows. Although this works pretty much like the code completion offered by other IDEs, it is case-sensitive. For example, typing Na after hitting Control+space will list all methods that have that substring, such as getName and setName; typing get will list each method that starts with the string get and methods where the string get occurs somewhere in the method name.

Another great feature offered by Android Studio is Smart Type Completion. If you press Control+Shift+space on Mac or Ctrl+Shift+space in Windows for completion assist, Android Studio will filter the suggested item list with compatible return types. This offers smart and context aware code completion. If you hit Control+Shift+space after typing Na, which would be assigned to a String variable, you get only getName but not setName.

Commenting Out Code Blocks

Commenting out a piece of code might be the most used feature of an IDE. The key combinations Control+Shift+/ on Mac or Ctrl+Shift+/ in Windows will comment out the selected portion of the code with the proper syntax.

Moving Code Blocks

Moving code blocks without cut and paste can be very effective and helpful. Android Studio supports the following commands to help you to move the code around in the editor without cut and paste:

• Move line up: Command+Shift+ up arrow on Mac (Ctrl+Shift+up arrow in Windows)—Because the editor is context aware, if the line is broken into several lines, all related lines are moved.
• Move line down: Command+Shift+ down arrow on Mac (Ctrl+Shift+ down arrow in Windows)—Because the editor is context aware, if the line is broken into several lines, all related lines will be replaced.
• Move line to the top: Command+Shift+ up arrow on Mac (Ctrl+Shift+ up arrow in Windows)—Because the editor is context aware, it will not move a variable or method above the class declaration.
• Move line to the bottom: Command+Shift+ down arrow on Mac (Ctrl+Shift+ down arrow in Windows)—Because the editor is context aware, it will not move a variable or method outside the class parenthesis.

All options also work with selected blocks of code, enabling you to move large pieces of code blocks.

Navigating Inside the Editor

The capability to jump to the right place in the file you are editing can greatly reduce the time you spend navigating. Android Studio is very helpful and offers the following flexible options:

• Move cursor to the last editing position: Command+Shift+Delete on Mac (Ctrl+Shift+Backspace in Windows)
• Move cursor to the start of the current code block: Command+Option+[ on Mac (Ctrl+Shift+[ in Windows)
• Move cursor to the end of the current code block: Command+Option+] on Mac (Ctrl+Shift+] in Windows)
• Move cursor to the previous word: Option+left arrow on Mac (Ctrl+left arrow in Windows)
• Move cursor to the next word: Option+right arrow on Mac (Ctrl+right arrow in Windows)
• Select and move cursor to the previous word: Option+Shift+left arrow on Mac (Ctrl+Shift+left arrow in Windows)
• Select and move cursor to the next word: Option+Shift+right arrow on Mac (Ctrl+Shift+right arrow in Windows)

Refactoring

Refactoring is another area where Android Studio shines. From changing a variable or method name to extracting a block of code to a method, Android Studio offers many powerful refactoring options; they are covered later in this chapter, in the section “Code Refactoring in Android Studio.”

Refactoring in Android Studio also checks other types of resources and performs string name checking to make sure the refactoring does not cause any compilations or runtime problems.

Inserting a Live Template

When you want to add any of the templates to your code, just type the name of the Live Template in the editor. It will auto-complete to easily add it to your code. Figure 4.34 shows the auto-complete drop-down for the fori Live Template.

After you add the fori Live Template to your Java code, it will highlight the variables you need to edit to implement your own custom for loop, as shown in Figure 4.35. When you type your own variable name and press Enter or Tab, the cursor will automatically move to the next variable to edit and so on. This action makes it very easy to customize a Live Template.

This is not the only way to add Live Templates to your code. You can also navigate to code from the Android Studio menu and click Insert Live Template or just use the shortcut (Command+J in Mac or Ctrl+J in Windows) to list all available Live Templates for the current context, as shown in Figure 4.36.

Another way to add a Live Template is to surround your code selection with the Live Template. After you select the code, navigate to the Code menu and then select Surround with Live Template or just press Option+Command+J on Mac Alt+Ctrl+J on other OSes to surround the selected code block with the code snippet, as shown in Figure 4.37.

We discussed Live Templates Java code in this section but they are available for all the structured files editable on Android Studio. If you navigate to HTML/XML, you can see the templates for HTML and XML files. If you expand the Android group, you will see around 18 (this number can change for the new versions of Android Studio) preconfigured live templates on the list. Toast Live Template is a good example for that. You can type Toast into your activity class and create a Toast object easily with Live Template.

We suggested expanding all the groups and exploring all the predefined templates. Try to use them in your application to get in the habit of using the templates. Keep in mind that there are pre-implemented code templates to launch activities, such as the starter template. If you need to define a constant (final) Java variable, just typing const, it will get the const Live Template and write a final variable for you.

Creating Live Templates

According to your applications, habits, or code practices you may need additional templates to speed your application development. In that case, you need to create your own template to share with your team to increase code reusability.

Create a Surrounding Template

The Live Templates that are able to surround selected text appear under the surround group, as shown in Figure 4.42.

Let's create a template to surround selected code text with an if statement that checks whether a variable is null.

The process is the same as adding a template but you also need to define where in the template the selected text will be placed. You do that by defining the $SELECTION$ variable. You can see the sample template IFS, shown in Figure 4.42.

You can also add live templates to surround selected code with block comments. If it is easier for you to remember Live Template shortcuts than the Android Studio block comment key combination (Option + Command + /), it might be easier for you to create a live template with a synonym to add a block comment.