Developer Phil — An Android Developer's Blog

Renaming Your Gradle Build Files

Mon, 19 Feb 2018 08:00:00 -0500

In a multi-module project, searching for the right build.gradle can be tricky. After all, everything is called build.gradle so using our trusty Open File doesn’t help much. One neat trick to organize your code is to rename your build.gradle file to something meaningful like app.gradle, my-feature.gradle, and so on.

How does it work

When you declare a module in your settings.gradle, the build system will look for a file named build.gradle in a folder corresponding to the module’s name. In other words, if you declare an :app module, gradle will expect the build file to be located at app/build.gradle.

Turns out that we can ignore this convention from our settings.gradle with the project.buildFileName property.

Adding the following snippet to your settings.gradle will rename each module’ s build.gradle file to its module’s name. e.g. app.gradle. The root build.gradle itself won’t be renamed.

// Add this at the end of settings.gradle
rootProject.children.each { subproject -> 
     subproject.buildFileName = "${subproject.name}.gradle" 
}

If you are using nested modules, you will need to add a bit of recursion to the mix to rename each submodule in the hierarchy. Replace the code above with the following:

// Add this at the end of settings.gradle
void rename_build_file_to_module_name(project) {
  project.buildFileName = "${project.name}.gradle"
  project.children.each { child -> rename_build_file_to_module_name(child) }
}

// Will rename every module's build.gradle file to use its name instead of `build`.
// E.g. `app/build.gradle` will become `app/app.gradle`
// The root build.gradle file will remain untouched
rootProject.children.each { subproject -> rename_build_file_to_module_name(subproject) }

That’s all there is to it, we now have a new convention to look for files named after the module.

Renaming the files

Now that gradle knows where to find the files… you actually need to rename the files on disk! You can go at it manually or run the following script at the root of your project.

#!/usr/bin/env bash
if [[ ! -f settings.gradle ]] ; then
    echo 'Make sure to run this at the root of your project'
    exit 1
fi

find . -iname build.gradle -not -path ./build.gradle  | while read build_file; do
    moduledir=$(dirname $build_file)
    modulename=$(basename $moduledir)
    new_build_file="$moduledir/$modulename.gradle"
    echo "Renaming'$build_file' to $new_build_file"
    mv $build_file $new_build_file
done

The source code for this post is available here

Nested Modules in Gradle

Fri, 19 Jan 2018 08:00:00 -0500

There are a many reasons to split your app in modules or projects¹. For a start, it’s mandatory to deploy an Instant App. It’s also a good way to speed up your incremental builds thanks to compilation avoidance.

But, no matter what your reasons are, at some point, you will end up with a bunch of folders sorted alphabetically at the root of your project, and that will get confusing.

Thankfully, Gradle allows us to organize our modules in folders.

In this post, we will start from a flat structure:

And migrate it to a nested structure:

Step 1: Move the modules to a subfolder

This is the most straightforward part: you are creating good old folders on your file system. In this example, we will move our features to a folder named feature and our helpers to a folder named helpers. Much like packages names, the trick here is to create a hierarchy that makes sense for your project. Note that the project won’t compile just yet. That’s coming next.

Step 2: Update the project references

Gradle needs to be told the full path to a module. So you will need to update it in your settings.gradle file.

Since we moved our features to the feature/ folder, the new path for :my-first-feature would be :feature:my-first-feature. Basically, it’s the same file path where the path separator is a colon instead of a forward/backward slash.

// settings.gradle
include ':app',
    ':feature:my-first-feature',
    ':feature:my-second-feature',
    ':helpers:string-helpers',
    ':helpers:activity-helpers'

You will also need to update your build.gradle files wherever they are referencing a module that you just moved.

// app/build.gradle
// ...
dependencies {
    implementation project(":feature:my-first-feature")
    implementation project(":feature:my-second-feature")
    implementation project(":helpers:activity-helpers")
    implementation project(":helpers:string-helpers")
    // ...
}

The final result

Perform a Gradle Sync from Android Studio and you will be ready to go.

If you are executing a command on a nested module from the terminal, you will need to specify the module’s full path:

./gradlew :feature:my-first-feature:check

Caveats

The Android View

The hierarchy is only visible from the project view in Android Studio . The ‘Android’ view will flatten the hierarchy.

IML files

The IDE might get confused the first time you move your folders. If you see that Android Studio is not able to resync the project, delete all of the *.iml files in the project and resync.

The source code for this post is available here

You will hear about multi-module projects and multi-project builds… They both represent the exact same thing but the naming varies between the IDE and the build system. What Android Studio and Intellij call a module, Gradle calls a project. So everything declared in your settings.gradle refers to a Gradle project. This is also the reason why we write implementation project(':helper') when we want to import another module. ↩

No, You Can Not Override the Home Button... But You Don't Have To!

Wed, 15 Jun 2016 21:50:00 -0400

About The Home Button

Every once in a while, somebody will ask “Can I override the Home button?”. The response usually reads like this:

Of course you can’t! Handling the back button is already hard enough as it is, can you imagine what the world would look like if developers were allowed to mess with the home button!

Behind this snarky answer lies a couple of truths:

It would break the user’s expectations if the home button didn’t return home directly
Users could get trapped in an app
It would not cover every cases
- What if the user leaves the app because of a phone call?
- What if the user turns off the phone?
- What if the user switched to another app by tapping on the “recents” button?

So, in hindsight, unless you are writing a kiosk¹ application, what you are probably looking for is a way to know when the user is leaving the Application. This would be so easy if the application had an onStop() method, right?

The Missing Application onStart() and onStop()

Actually, why stop at onStop()? Let’s go one step further and try to map the whole foreground/background lifecycle so that we always know in what state we are and when that state changes.

Why would you want that? Well, let’s say that your app has a messaging feature. If you receive a message and the app is in foreground, you might want to show a notification in your user interface. On the other hand, If the app is in background, showing a notification would be more appropriate.

Other times, you might want to be notified of the whole foreground/background lifecycle to track session lengths. Or you might want to know if the user is moving on to something else so that you can clear your caches.

Thankfully, you can get this information in a reliable way without resorting to crazy solutions like using ActivityManager#getRunningTask or instrumenting the activity lifecycle to detect when an Activity#onStop() is not followed by an Activity#onStart() fast enough.

Getting Notified When The App Goes In Background

Starting with API Level 14 (Android 4.0 / ICS), we have access to the Application#onTrimMemory(int level) method. This method contains an interesting level called TRIM_MEMORY_UI_HIDDEN that can be used to know that we are going to the background.

Here is an example of a custom Application class:

public class MyApplication extends Application {
    // ...
    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        if (level == TRIM_MEMORY_UI_HIDDEN) {
           isBackground = true;
           notifyBackground();
        }
    }
    // ...
}

Yay!! Now you can know for sure that your app is being sent to the background!

EDIT: Getting Notified When The Screen Turns Off

As noted by Guillaume Imbert in the comments, onTrimMemory is not called when the screen gets turned off. To handle this, you will need to register a BroadcastReceiver on Intent.ACTION_SCREEN_OFF.

public class MyApplication extends Application {
  // ...
  @Override
    public void onCreate() {
        super.onCreate();
        // ...
        IntentFilter screenOffFilter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
        registerReceiver(new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
              if (isBackground) {
                  isBackground = false;
                  notifyForeground();
              }
            }
        }, screenOffFilter);
      }
}

Note that there is no need to listen for Intent.ACTION_SCREEN_ON, it’s all handled down below

Getting Notified When The App Returns In Foreground

There is no flag or trim level to know that we are re-entering the foreground. The best that we can do is wait for an Activity#onResume(). We could add all that code in a base Activity but that is not necessary. It would be cleaner to keep the foreground logic close to the background logic, so we will take advantage of Application#registerActivityLifecycleCallbacks(). This method allows you to add an ActivityLifecycleCallbacks which, as the name implies, calls you back for each and every lifecycle event. In our case, it means that we can have code that will run for every Activity#onResume() without modifying any of our activities.

Here is what it would look like in our custom Application class:

public class MyApplication extends Application {
    // ...
    @Override
       public void onCreate() {
           super.onCreate();

           registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
               // ...
               @Override
               public void onActivityResumed(Activity activity) {
                 if (isBackground) {
                     isBackground = false;
                     notifyForeground();
                 }
               }
               // ...
           });
       }
       // ...
}

Tying It All Together

Alright, here is a more complete sample to be notified when the app enters foreground and is sent to background.

public class MyApplication extends Application {

    // Starts as true in order to be notified on first launch
    private boolean isBackground = true;

    @Override
    public void onCreate() {
        super.onCreate();

        listenForForeground();
        listenForScreenTurningOff();
    }

    private void listenForForeground() {
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            //...
            @Override
            public void onActivityResumed(Activity activity) {
                if (isBackground) {
                    isBackground = false;
                    notifyForeground();
                }
            }
            //...
        });
    }

    private void listenForScreenTurningOff() {
        IntentFilter screenStateFilter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
        registerReceiver(new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                isBackground = true;
                notifyBackground();
            }
        }, screenStateFilter);
    }

    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        if (level == TRIM_MEMORY_UI_HIDDEN) {
            isBackground = true;
            notifyBackground();
        }

    }

    private void notifyForeground() {
        // This is where you can notify listeners, handle session tracking, etc
    }

    private void notifyBackground() {
        // This is where you can notify listeners, handle session tracking, etc
    }

    public boolean isBackground() {
      return isBackground;
    }
}

In a Nutshell

Target API 14
Use Application#onTrimMemory(int level) and TRIM_MEMORY_UI_HIDDEN to know when your are being sent to the background
Handle the screen turning off by registering a Broadcaster receiver for Intent.ACTION_SCREEN_OFF
Register an ActivityLifecycleCallbacks to know when the app comes back to the foreground
Don’t try to override the home button
Be a nice person

Oh and big thanks to Ben Oberkfell for reviewing this post!

A kiosk application is basically having an app from which the user can’t escape. It is named that way because it usually means that a tablet will be embedded in a kiosk to display only one app. Think about “Point of Sales” scenario like ordering food in a restaurant, buying a train ticket, etc. If you are in this situation, the best way to go is to configure your app to be a single-use device. All the steps to achieve that are outlined in this codelab ↩

Android Studio Tips Of the Day - Roundup #6

Tue, 24 Feb 2015 18:10:00 -0500

This is the sixth roundup of my Android Studio Daily Tips that I post on Google+
You can take a look at the previous post here.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Refactor This

This is a shortcut to contextually show all the available refactorings for the current selection. This list is keyboard searchable and you can use the number on the left for a quicker access

Shortcut (Menu):

Mac: Ctrl+T
Windows/Linux: Ctrl+Alt+Shift+T

Navigate to parent

If you are in a method that is overriding a parent class (e.g. Activity#onCreate()), this will navigate to the parent implementation.

If you are on the class name, it will navigate to the parent class.

Shortcut :

Mac: Cmd+U
Windows/Linux: Ctrl+U

Recently Changed Files

This is a variation of the “Recents” popup that lists files that were recently modified locally. It is sorted in order of modification (most recently edited on top). A nice bonus is that you can type to filter the list.

Shortcut (Menu):

Mac: Cmd+Shift+E
Windows/Linux: Ctrl+Shift+E

Jump to Last Tool Window

Sometimes, you return to the editor from a panel but find yourself having to go back to this panel. e.g. browsing find usages. With this, you can go back to a panel without your mouse.

Shortcut: F12 (might interfere with the OS’s default keybindings)

It helps you navigate between your layout and your activity/fragment with ease. There is also a shortcut in the gutter next to the class name and one at the top of the layout file.

Shortcut (Menu):

Mac: Ctrl+Cmd+Up
Windows/Linux: Ctrl+Alt+Home

Extract Variable

This is a shortcut to extract a variable without going through the refactoring menu.

This is very useful when you are generating code on the fly as you can avoid typing the variable declaration and go straight to the value. The IDE will then generate the declaration and it will come up with some suggestions on how to name the variable.

Additional tip:

If you want to change the declaration type to something more generic (e.g. List instead of ArrayList), you can press Shift+Tab and it will give you a list of valid types.

Shortcut (Menu):

Mac: Cmd+Alt+V
Windows/Linux: Ctrl+Alt+V

Extract Parameter

This is a shortcut to extract a parameter without going through the refactoring menu.

This thing is useful when you realize that a method could be generified by extracting one part as a parameter. The way it works is that it will take the current value, make it a parameter and copy the old value as the parameter for each caller.

Additional tip:

You can also keep the original method and have it delegate to the new one by ticking the “delegate” box.

Shortcut (Menu):

Mac: Cmd+Alt+P
Windows/Linux: Ctrl+Alt+P

Extract Method

Following in my streak of extract refactoring, here is the one to extract a code block in a new method.

This thing is extremely useful. Whenever you encounter a method that is starting to become a bit complex, you can use this to safely extract a portion in another method. I say safely because the IDE won’t make a silly copy-paste mistake like we might do.

Additional tip:

Once you are in the extractin dialog, you can change the visibility of the method and the parameter names.

Shortcut (Menu):

Mac: Cmd+Alt+M
Windows/Linux: Ctrl+Alt+M

Inline

So you have gone a bit crazy with extraction and now you have too much stuff? You can do the reverse operation, which is called “inline”.

This will work with methods, fields, parameters and variables.

Shortcut:

Mac: Cmd+Alt+N
Windows/Linux: Ctrl+Alt+M

Rename

With this, you can rename a variable, field, method, class and event package. This will, of course, make sure that the renaming makes sense in the context of your app, it won’t simply do a find and replace in all files!

Additional Tip:

If you can’t remember this shortcut, you can always invoke the quick fix shortcut and it will always include the rename refactoring.

Shortcut: Shift+F6

Pull Up / Push Down

When we talk about pulling something up, we mean that we will take something in the current class (usually a method or a field) and send it to the parent class or interface.

If the parent is a class, the content will be moved. If the parent is an interface, it will declare the method as part of the interface, keep the method in your class and add the @override annotation.

When we talk about pushing members down, that is exactly the opposite operation, we are sending content from the parent class/interface in the child class.

Shortcut:

Mac: Ctrl+T and choose pull members up / push members down
Windows/Linux: Ctrl+Alt+Shift+T and choose pull members up / push members down

Android Studio Tips Of the Day - Roundup #5

Mon, 09 Feb 2015 18:10:00 -0500

This is the fifth roundup of my Android Studio Daily Tips that I post on Google+
You can take a look at the previous post here.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Enter vs Tab for Code Completion

There is an interesting difference whether you use code completion with tab or with enter.

Using enter will complete the statement as you would expect. Using tab will complete the statement and delete everything forward until the next dot, parenthese, semicolon or space.

Shortcut (during code completion): enter or tab

Navigate to parent

If you are in a method that is overriding a parent class (e.g. Activity#onCreate()), this will navigate to the parent implementation.

If you are on the class name, it will navigate to the parent class.

Shortcut :

Mac: Cmd+U
Windows/Linux: Ctrl+U

Return to the Editor

A bunch of shortcuts will take you away from the editor (type hierarchy, find usages, etc.)

If you want to return to the editor, your options are:

Escape: This will simply return the cursor to the editor.
Shift+Escape: This will close the current panel and then return your cursor to the editor.

Shortcut :

Return and keep panel open: Escape
Close panel and Return: Shift+Escape

Jump to Last Tool Window

Sometimes, you return to the editor from a panel but find yourself having to go back to this panel. e.g. browsing find usages. With this, you can go back to a panel without your mouse.

Shortcut: F12 (might interfere with the OS’s default keybindings)

Hide All Panels

Puts the editor in some sort of full screen mode. Invoking the shortcut a second time returns all panels to their previous state.

Shortcut :

Mac: Cmd+Shift+F12
windows/linux: Ctrl+Shift+F12

Open a Panel by Its Number

You might have noticed that some of the panels have a number to the left of their name. This is a shortcut to open them!

Just in case you don’t see the panel names, click the box thing in the lower left corner of the IDE.

Shortcut :

Mac: Cmd+Number
windows/linux: Alt+Number

Parameter Info

This is the same list of parameter names as the one that appears when you are writing a method call. It is useful when you want to see an existing method’s params.

The Parameter under your cursor will be in yellow. If nothing is in yellow, that means that the method call is not valid, probably something that is not casted right (e.g. a float in an int param).

When you are writing a method call and you dismiss it by accident, like I usually do, you can also type a comma (,) to trigger the parameter info.

Shortcut :

Mac: Cmd+P
windows/linux: Ctrl+P

The Switcher

So this thing is pretty much the alt+tab / cmd+tab of the IDE. It allows you to navigate to a tab or a panel.

Once it is opened, as long as you hold the ctrl key, you can navigate quickly by using the number or letter shortcut. You can also close a tab or a panel by pressing backspace when it is selected.

Shortcut: Ctrl+Tab

Context Info

So this will show you where you are when your scope definition is out of the scrolling area. Usually, this will be the name of the class or inner class but it might also be the current method name.

Its better use, IMO, is to get a quick look at what the current class extends or implements.

It also works in xml files.

Shortcut: Ctrl+Shift+Q

Android Studio Tips Of the Day - Roundup #4

Mon, 02 Feb 2015 18:05:00 -0500

This is the fourth roundup of my Android Studio Daily Tips that I post on Google+
You can take a look at the previous post here.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Analyze Data flow to Here

This will take the current variable, parameter or field and show you the path it has taken to get here! This is very useful when you are entering an unfamiliar place in the code base and you want to understand how this parameter got there.

There is also the reverse operation “Analyze Data Flow from Here” that will show you where your variable, field or return type will end up.

Shortcut : There is no keyboard shortcut for this…

Menu: Analyze → Analyze Data Flow to Here
Find action: Analyze Data Flow to Here

Sublime Text Multi Selection

This one is particularly nice!
It will take the current selection, select the next occurrence and add a cursor there. This means that you can have multiple cursors in the same file! Everything you type will be written at each cursor.

Shortcut :

Mac : Ctrl+G
Windows/Linux: Alt+J

Column Selection

Enable column selections, also known as block selection. Basically, if you select down, it will go down and not bother wrapping to the end of the line.

This will also put a cursor after each line of the block selection from where you can type.

Shortcut :

Mouse: Alt+MouseDrag
Mac : Cmd+Shift+8
Windows/Linux: Shift+Alt+Insert

Postfix Completion

This one is not very intuitive but still pretty powerful. Basically, it is a way to wrap the current statement in something else without having to press the left key a bunch of times to get there.

E.g. to iterate a list, you could go “myList.for”, press tab and it would generate the for loop for you.

You can get a list of what you can type by typing a dot after a statement and looking through the options after all the possible completions.

Some of my personal favorites:

.for (for a foreach)
.format (wraps a string in String.format())
.cast (wraps a statement in a type cast)

Compare With Clipboard

This will take the current selection and do a diff with the content of your clipboard.

Shortcut:

Mouse: right-click the selection and select Compare With Clipboard
Find action: compare with clipboard

Stop Process

This will stop the currently running task or show a list of possible tasks to stop if there is more than one.

Pretty useful to stop debugging or abort a build.

Shortcut :

Mac : Cmd+F2
Windows/Linux: Ctrl+F2

Show Execution Point

This will put the cursor back to where you are debugging right now.

The usual case is:

You break somewhere
You start looking around in this file and then a bunch of other files
You invoke this shortcut to return exactly to where you were in your step-by-step debugging session

Shortcut (when debugging) : Alt+F10

This will show you the most frequent version control operations. If your project is not under git or another sytem, it will at least give you a local history maintained by Android Studio.

Shortcut :

Mac: Ctrl+V
Windows/Linux: Alt+`

Compare With Branch (Git)

Assuming that your project is under Git, you can compare the current file or folder with another branch. Pretty useful to get an idea of how much you have diverged from your main branch.

Shortcut :

Menu (for git): VCS -> Git -> Compare With Branch
Find Actions: Compare With Branch

Android Studio Tips Of the Day - Roundup #3

Mon, 26 Jan 2015 19:00:00 -0500

This is the third roundup of my Android Studio Daily Tips that I post on Google+
You can take a look at the previous post here.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Toggle Breakpoints

The next few tips will be about debugging. So let’s start with the most basic one: adding a good old breakpoint!! I am pretty sure that by now you have debugged an app and know how to toggle it by left-clicking in the left gutter. Here is the correct shortcut to toggle it without your mouse.

Shortcut:

OSX: Cmd+F8
Windows/Linux: Ctrl+F8

Conditional Breakpoints

In a nutshell, only do break when a certain condition is met. You can enter any java expression that returns a boolean based on the current scope. And do enjoy the fact that the condition textbox supports code completion!

Shortcut:

Right click on a breakpoint and enter a condition.

Logging Breakpoints

This is a breakpoint that logs stuff instead of breaking. This can be useful when you want to log some stuff right now but cannot or don’t want to redeploy with logging code added.

Shortcut:

Right click on a breakpoint, uncheck Suspend and type your message in “Log evaluated Expression”

Temporary Breakpoints

This is a way to add a breakpoint that will be removed automatically the first time you hit it.

Shortcut:

Mouse: Alt+LeftClick in the left gutter
Mac: Cmd+Alt+Shift+F8
Windows/Linux: Ctrl+Alt+Shift+F8

Disable Breakpoints

This will disable the breakpoint. Particularly useful when you have some complicated conditional or logging breakpoint that you don’t need right now but don’t want to recreate next time.

Shortcut:

Mouse: Alt+LeftClick on an existing breakpoint in the left gutter
There is no keyboard shortcut but you can create one if you use it often enough.

Attach Debugger

Start debugger even if you didn’t start the app in debug mode. This is very useful since you don’t have to redeploy the app to start debugging. It is pretty useful also when somebody is testing the app, encounters a bug and give you his device.

Shortcut:

Mouse: click on its icon or select the menu item Build → Attach to Android Process
There is no keyboard shortcut but you should create one!

Evaluate Expression

This is used to inspect a variable’s content and evaluate pretty much any valid java expression right there, right now. Just be aware that if you are mutating state, it will stay that way when you resume the execution of the program.

Shortcut:

Alt+F8

Inspect Variable

This evaluates an expression without opening the Evaluate Expression dialog

Shortcut:

Alt+LeftClick on an expression

Mark Object

During a debugging session, this will let you add a label to a particular object so that you can identify it later. Very useful in those debugging sessions where you have a bunch of similar object and you want to know if it is the same one as before.

Shortcut (from the variables or watch panel):

Mouse: right-click and select “Mark Object”
OSX : F3 with the object selected
Windows/Linux: F11 with the object selected

Analyze Stacktrace

This will take a stacktrace and make it clickable just as if it had been shown in logcat. This is particularly useful when copying a stacktrace from a bug report or from a terminal.

Additional tip:

You can also analyze a proguarded stack trace using the “ProGuard Unscramble Plugin”

Shortcut : There is no shortcut for this…

Menu: Analyze → Analyze Stacktrace
Find action: analyze stacktrace

Android Studio Tips Of the Day - Roundup #2

Thu, 18 Sep 2014 19:29:36 -0400

This is the second roundup of my Android Studio Daily Tips that I post on Google+
You can take a look at the previous post here.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Duplicate Lines

cmd+d ctrl+d

Just as it says: it will copy the current line and paste it below without interfering with your clipboard. It can be pretty useful when it’s used with the move line shortcut!

Expand/Shrink Selection

alt+up/down ctrl+w / ctrl+shift+w

This will contextually expand the current selection. e.g. it will select the current variable, then the statement, then the method, etc.

Surround with

cmd+alt+t ctrl+alt+t

This can be used to wrap a block of code in some structure. Usually an if statement, a loop, a try-catch or a runnable.

If you have nothing selected, it will wrap the current line.

Recents

cmd+e ctrl+e

Using this, you get a searchable list of the most recently consulted files!

Live Templates

cmd+j ctrl+j

The live template is a way to quickly insert a snippet of code. The interesting thing with live templates is that they can be parameterized with sensible defaults and guide you through the parameters when you insert it.

Additional Tip:

You don’t need to invoke the shortcut if you know the abbreviation. You only need to type it and complete using the Tab key.

Move Methods

cmd+alt+up/down ctrl+shift+up/down

This is like the Move Line shortcut but applied to whole methods. It allows you to move a method below or above another one without copy-pasting.

The real name of this action is Move Statement. Meaning that it moves any kind of statement. E.g. you can reorder fields and inner classes.

Complete Statement

cmd+shift+enter ctrl+shift+enter

This will generate the missing code to complete a statement The usual use cases are:

Add a semicolon at the end of the line, even if you are not at the end of the line
Add the parentheses and curly braces after an if, while or for
Add the curly braces after a method declaration

Additional Tip:

If a statement is already completed, it will go to the next line even if you are not at the last character of the current line.

Last Edit Location

cmd+shift+backspace ctrl+shift+backspace

This will make you navigate through the last changes you made. This is different from clicking the back arrow in the toolbar in that it makes you travel within your edition history and not your navigation history.

Join Lines and Literals

ctrl+shift+j ctrl+shift+j

This is doing more than simulating the delete key at the end of the line! It will preserve formatting rules and it will also:

Merge two comment lines and remove the unused //
Merge multiline strings, removing the + signs and the double-quotes
Join fields and assignments

Additional Tip:

If you select a string that spans multiple lines, it will merge it on a single one.

Select In

alt+f1 alt+f1

Takes the current file and asks you where to select it. The most useful shortcuts IMHO are to open in the project structure or in your file explorer. Note that each action is prefixed by a number or a letter, this is the shortcut to invoke it quickly.

Usually, I’ll go Alt+F1 then Enter to open in the project view and Alt+F1+8 to reveal the file in Finder on the Mac.

You can invoke this from a file or directly from the project view.

Unwrap/Remove

cmd+shift+delete ctrl+shift+delete

This will remove the surrounding code. It could be to remove an if statement, a while, a try/catch or even a runnable. This is exactly the opposite of the Surround With shortcut.

Android Studio Tips Of the Day - Roundup #1

Sat, 06 Sep 2014 12:03:09 -0400

Turns out that I am not that good at keeping a commitment. The previous post was supposed to be a new series that I would contribute to but here we are, one year later!

So I am starting this all over again! Instead I am doing a series of daily posts on Google+ and I will post recaps here, much like what Daniel Lew did a while back.

Note that since I am starting a new series on G+, there will be some duplications with the previous post.

If you want the most up to date tips, follow me on google+ or subscribe to the Android Developer Tools Community. Pavlos-Petros Tournaris also collected all the current tips on github, So if you want a sneak peak at the content of the next blog posts, check it out!

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+

Highlight All the Things

cmd+shift+f7 ctrl+shift+f7

This will highlight every occurrence of a symbol in the current file. This is more than some simple pattern matching, it will actually understand the current scope and only highlight what is relevant.

You can then navigate up or down using the shortcuts from Edit → Find → Find Next/Previous

Additional tips:

Highlighting a “return” or a “throw” statement in a method will also highlight all the exit points of the method.
Highlighting the “extends” or the “implements” portion of the class definion will also highlight the methods that are overriden/implemented.
Highlighting an import will also highlight where it is used.
You can cancel the highlighting by pressing Escape.

Move Between Methods and Inner Classes

ctrl+up/down alt+up/down

This wil move your cursor to the name of the next method or class in the current file.

If you are in the body of a method, going up will put the cursor on its name. This can be very useful because it puts you at the right place to refactor or find the usages of this method.

cmd+f12 ctrl+f12

The idea here is to show an outline of the current class and navigate in it. The best thing about it is that you can filter using your keyboard. This is a very efficient way to go to a method you know by name.

Additional tips:

You can use camel-case matching when typing to filter the list. Example: typing “oCr” would find “onCreate”
You can toggle a checkbox to also show anonymous classes. It could be useful in some cases like if you want to go directly to the onClick method in an OnClickListener.

ctrl+alt+h ctrl+alt+h

This will show you the possible paths between a method’s declaration and its invocations!

Quick Definition Lookup

alt+space ctrl+shift+i

Ever wondered whats the implementation of a method or class but don’t want to lose your current context? Use this shortcut to look it up in place.

Collapse Expand Code Block

alt+plus/minus ctrl+shift+plus/minus

The goal of this feature is to let you hide things you don’t care about at the moment. In its simplest form, it will hide a whole code block (e.g. ignoring the import list when you open a new file). A more interesting use is that it will hide the boilerplate around simple anonymous inner classes and make it look like a lambda expression.

Additional tip:

You can setup the default folding behaviour in the preferences at Editor → Code Folding

Bookmarks!

Toggle Bookmark

f3 f11

Toggle Bookmark With Mnemonic

alt+f3 ctrl+f11

If you assign a number, you can go back to the bookmark using this shortcut: ctrl+number

Show Bookmarks

cmd+f3 shift+f11

Find Actions

cmd+shift+a ctrl+shift+a

You can invoke any menu or action known to Android Studio by its name! This is pretty useful for commands that you use once in a while but don’t have a shortcut for.

Additional tip:

If there is a shortcut associated to the action, it will be shown by its side

Move Lines Up/Down

alt+shift+up/down alt+shift+up/down

Yeah. This will move lines up or down. Not much more to say. Enjoy!

Delete Line

cmd+backspace ctrl+y

It deletes the current line or selection.

Android Studio Tips & Tricks: Moving Around

Mon, 14 Oct 2013 15:30:04 -0400

There are two things that you should know about me:

I am an IDE enthusiast
I am a productivity geek

So two years ago, when I switched to Intellij IDEA, on which Android Studio is based, I spent a lot of time looking for shortcuts and techniques to become more productive. Since you are here, I suspect you might be doing the same so I’ll try to make it easier and faster for you!

In this series, we will go from very basic productivity tricks that everyone should know to more advanced topics in Android Studio.

About Keymaps

Android Studio provides different keymaps (the mapping between shortcut keys and an action). You can see which keymap you are using in Settings->Keymap.

It wouldn’t be practical to list the shortcuts for every keymap so the following will be used:

Windows: Default
Linux: Default
OSX: Mac OSX 10.5+ (not the default one! Jetbrains and I highly suggest that you use this one!)

Moving Around

We spend a lot of time navigating in our code base, let’s try to do it more efficiently.

Opening Class/File/Symbol

Open class

cmd+o ctrl+n

Imagine that you must go to a class named “MainActivity”, just use this shortcut and start typing “MainA”.

Open File

cmd+shift+o ctrl+shift+n

Works like the “Open Class” shortcut but on every files in your project. It is very useful to open your AndroidManifest.xml or anything that sits in the res/ or assets/ folder.

Open Symbol

cmd+alt+o alt+shift+n

A very powerful but little less known variation of the previous tips: You can use this to go directly to a method or field by searching its name!

For example, if you know that you have a method named getFormattedDate() somewhere in your project, you can type it in the Open Symbol dialog to go directly to it.

Tips

Partial Matching

You can enter incomplete strings and it will work. For example. if you are searching for a class named “ItemDetailFragment”, you can actually type “IDF” and it will find it.

Line Number

Imagine that your colleague just told you that the juicy part is in ExcitingClass at line 23. You can open the file directly by appending a “:” to the class name in the Open Class dialog. e.g.:

ExcitingClass:22

You can also combine it with partial matching and type something like:

EC:22

Recent Files

Recently opened files

cmd+e ctrl+e

This will show a popup listing the files you navigated to previously.

Recently edited files

cmd+shift+e ctrl+shift+e

Same as the above but listing only files that have been edited.

Tip:

Start typing to filter the list.

Navigate Back/Forward

cmd+alt+left/right ctrl+alt+left/right

To understand this shortcut, think about how the back and forward buttons work in a web browser. Now, instead of thinking in web pages, think about source code! So when you drill down in code or open a new file, the IDE will remember where you where before, allowing you to quickly go back.

Last Edit Location

cmd+shift+backspace ctrl+shift+backspace

This is a variation on the “Navigate Back” shortcut that cycles between the locations where you typed something.

Picture yourself fixing a nasty bug. You think you have the solution so you start fixing it but then realize that you have to look at the android source code and a couple other classes in your project. You enter a function, which leads you to another class, which leads you to another thing and 20 steps later, you finally have the insight needed to complete your fix… but in which file and at what line where you again? Just use this shortcut and you are right back at the exact line where you stopped writing.

Show Usage

In a Persistent Panel

alt+f7 alt+f7

Shows where something is used. For a class member, it will show where reads and writes are made. For a method, it will show where it is called. For a class, it will show where new instances are created.

You can use the arrow keys and the return key to navigate trough results. You can then press the escape key to go back to the editor.

In Place

cmd+alt+f7 ctrl+alt+f7

Same as before but shows the information in a popup.

Goto Declaration/Implementation (Drill Down)

Here are three shortcuts to drill down into a symbol:

Goto Declaration

cmd+b ctrl+b

cmd+click ctrl+click

Goes to the declaration of the class, method or variable. Mostly useful on classes and methods since it redirects to the implementation.

Goto Implementation

cmd+alt+b ctrl+alt+b

Shows a list of all the classes/interfaces implementing the selected class/interface. Also works on methods to find where they are implemented/overriden. On variables, it has the same effect as Goto Declaration

Goto Type Declaration

ctrl+shift+b ctrl+shift+b

When the caret is on a variable, it will go to the declaration of its type. For example, if I have the following line:

Developer phil = new Developer("Phil");

If the caret is on the variable “phil”, this shortcut will go to the declaration of the “Developer” class.

Goto Super

cmd+u ctrl+u

This will open the parent of the current symbol. Pretty much the opposite of Goto Implementation. If the cursor is in an overriden method, it will open its parent implementation. If the caret is in a class but outside the method or on the class name, it will open the parent class.

That’s all folks!

In the next article, we’ll take a look at more Navigation shortcuts!

Developer Phil — An Android Developer's Blog

Renaming Your Gradle Build Files

How does it work

Renaming the files

Nested Modules in Gradle

Step 1: Move the modules to a subfolder

Step 2: Update the project references

The final result

Caveats

The Android View

IML files

No, You Can Not Override the Home Button... But You Don't Have To!

About The Home Button

The Missing Application onStart() and onStop()

Getting Notified When The App Goes In Background

EDIT: Getting Notified When The Screen Turns Off

Getting Notified When The App Returns In Foreground

Tying It All Together

In a Nutshell

Android Studio Tips Of the Day - Roundup #6

About Keymaps

Refactor This

Navigate to parent

Recently Changed Files

Jump to Last Tool Window

Related File

Extract Variable

Extract Parameter

Extract Method

Inline

Rename

Pull Up / Push Down

Android Studio Tips Of the Day - Roundup #5

About Keymaps

Enter vs Tab for Code Completion

Navigate to parent

Return to the Editor

Jump to Last Tool Window

Hide All Panels

Open a Panel by Its Number

Parameter Info

The Switcher

Context Info

Android Studio Tips Of the Day - Roundup #4

About Keymaps

Analyze Data flow to Here

Sublime Text Multi Selection

Column Selection

Postfix Completion

Compare With Clipboard

Stop Process

Show Execution Point

VCS Operations Popup

Compare With Branch (Git)

Android Studio Tips Of the Day - Roundup #3

About Keymaps

Toggle Breakpoints

Conditional Breakpoints

Logging Breakpoints

Temporary Breakpoints

Disable Breakpoints

Attach Debugger

Evaluate Expression

Inspect Variable

Mark Object

Analyze Stacktrace

Android Studio Tips Of the Day - Roundup #2

About Keymaps

Duplicate Lines

Expand/Shrink Selection

Surround with

Recents

Live Templates

Move Methods

Complete Statement

Last Edit Location

Join Lines and Literals

Select In

Unwrap/Remove

Android Studio Tips Of the Day - Roundup #1