Live template android studio

Writing More Code by Writing Less Code with Android Studio Live Templates

An Android Tool Time Pro Tip

If you’ve written much Android code, you’ve probably made this mistake at least once:

What if I told you there was a way to guarantee you can avoid this mistake, and also use fewer keystrokes?

What is this magic I speak of? Live Templates!

If you’re an experienced IntelliJ user, you’re probably already aware of Live Templates — in which case skip ahead to the Android-specific templates included in Android Studio

Unless you’re getting paid by the keystroke, no one wants to write repetitive boilerplate code. It’s easier to show than explain, so here’s how they work.

As you can see, Live Templates are shortcuts displayed as code-completion options that, when selected, insert a code snippet that you can tab through to specify any required arguments.

For example, as shown above — typing “Toast” then hitting the Tab key inserts the code for displaying a new Toast with argument placeholders that you can enter, before hitting tab and moving on to the next argument.

Android Studio Live Templates: A Handy Reference

IntelliJ includes over dozens of Live Templates, and Android Studio features another 48 specific for Android development. Here’s a few of my favorites for easy reference

Live templates can also insert larger code snippets; such as starter which creates a static start(…) helper method to start an Activity:

Similarly, newInstance that creates a new Fragment instance with arguments, and ViewConstructors, adds generic view constructors to your custom View.

You can use the File > Settings > Editor > Live Templates menu option to see the full list.

Of course, if your favorite boiler plate isn’t already there, remember that you can:

Create Your Own Live Templates

Go to File > Settings > Editor > Live Templates. Click the Android group, and press the plus button to add a new Live Template.

You’ll want to choose an abbreviation to use the template, a description to remember what it does, and of course the code you’d like it to insert — like this example for writing a boolean Shared Preference value.

Notice that we’re fully qualifying the class paths, and most importantly that we replace the parts of our code snippet that will be different each time with variables indicated by wrapping the names with matching $ symbols.

With our new Live Template defined, we can type the abbreviation — select it from the autocompletion hint by pressing tab — and it will paste in our code snippet!

What code are you going to Live Templatize?

Источник

Write More with Less in Android Studio

How to Use Live Template to Increase Developer Productivity

Live template is JetBrains IDE feature that allows you to expand keywords into code snippets with editable fields. When you’re typing in Android Studio, sometimes you will be prompted with this option:

Live template is very useful for day to day programming tasks, in which it:

• Improves developer’s productivity.
• Provides auto complete for frequently used codes.
• Provides customizable and editable fields based on the context of your code.
• Reduces cognitive burden because you don’t have to remember boilerplate codes.

In this article, I will try to explain how to create and apply custom live templates, and 2 other templates which can be useful to improve your productivity: Postfix Completion and File Templates

These templates are also available for other JetBrains IDE.

Live Template

There are some live templates which are provided by Android Studio out of the box, but those are mostly only for Java codes. For example, if we type logd inside a function in Java code and select the prompted suggestion, it will complete your code into Log. d(TAG, “functionName: “); .

You can also use “Insert Live Template” shortcut (Default to ⌘J on MacOS and Ctrl + J on Windows/Linux) to complete any valid Live Template abbreviation if you don’t remember it. For example, on MacOs, type log and press ⌘J to see what happens.

To see existing or adding new live templates, go to Settings/Preferences then go to Editor | Live Templates .

Creating a custom live template

To create a new live template, click Add (+) at the top right corner of live template window, then select Live Template. In the template window, give it an abbreviation. Abbreviation is the keyword that you will use to invoke your live template and expand it to template text.

You can use Template Group to organise your custom templates into logical groups.

A few things that we need to know before creating our live templates:

Context

When you create a new live template, you will be prompted with a warning message which says “ No applicable contexts yet.” and there will be an option where you can define the context. This context will determine the type of files where the live templates will be available in.

Since we’re going to write live templates for Android, we will generally focus on Kotlin and XML context.

Tips: You can use the same abbreviation for different live templates that belong to different contexts. For example, you can define logd abbreviation in Kotlin context and it will only work when you’re typing in Kotlin file.

Variables

Variables are editable fields that can be changed at the time of usage. These variables can be user inputs or expressions that are evaluated by the IDE.

To add variables to your live templates, write $VARIABLE_NAME$ in template text field and then click Edit Variables. You should be able to edit your variables.

Here is the short explanation of each field:

• Name: The name of the variable.
• Expressions: Allows you to replace the variable with predefined functions.
• Default value: The value to be used if expression failed
• Skip if defined: Skips prompting user for input if expression is successfully evaluated.

There are 2 predefined variables that you can use: $END$ and $SELECTION$ .

• $END$ is the position of the cursor after template is expanded.
• $SELECTION$ will be replaced by the code that is currently in selection when the template is expanded. This is useful when you’re using “Surround with Live Template”.

Examples of Custom Templates

Here are some live templates that I find really useful and use regularly:

Injectable lateinit var

Tips: Use fully qualified name and ensure “Shorten FQ names” is enabled to allow Android Studio to automatically add necessary import statements.

Data Binding’s binding property

If you wish to use it in an Activity , you’ll have to create a separate live template.

Logging methods and parameters with Timber

Make sure to press Enter after you finished typing in the expression field, otherwise it won’t be saved.

Android XML TextView with predefined style

In Wantedly, we have a design system that we can use to style our TextView according to some predefined styles. Integrating this style into our live template makes it easier for us to choose the correct appearance for our UI elements.

Your cursor will follow the ordering of parameters defined in the Variables, i.e., in this live template example, the cursor will go from ID , VIEW_WIDTH , VIEW_HEIGHT , then STYLE even though STYLE was declared before both VIEW_WIDTH and VIEW_HEIGHT in the Template text. This makes it easier for us to order the variables logically.

Postfix Completion

Postfix completion is very similar to live templates, but is invoked after an expression in your code. An example of postfix completion is .when .

To see existing postfix completions, go to Settings/Preferences then go to Editor | General | Postfix Completion

Unfortunately, although we can edit certain keywords and behaviors of postfix completion, we can’t add custom postfix completion for Kotlin at the moment. 😔

File Templates

Another feature that is very similar to live template is file template. File template is available when creating a new file using File | New option.

To see existing or adding new file template, go to Settings/Preference then go to Editor | File and Code Templates and select Files tab.

To create a new file template, click + (Create Template) button at the top of the file templates window.

If you want to make use of live template inside your file template, ensure the “Enable Live Templates” checkbox below your template text is checked and add live template variable using #[[$Var$]]# format.

Example of File Template

For our Visit Android app, we use UseCase class that wraps the business logic into a single place. This file template allows us to easily create a new UseCase class that is also injectable.

File Header.java is the File Header template that you can find in the Includes tab.

Sharing your File Templates

To share your live templates with your team. You can check your template files, which are located in .idea/fileTemplates folder, into git. Then set your File and Code Templates’ Scheme to Project to tell Android Studio to use your file templates.

Live Template is a great feature that can easily improve your productivity as a developer. I have had a great experience with creating and using them and I hope that sharing my live template can inspire you to make your own live template. Let me know if there’s any interesting live template that I should know of!

Источник

Live template android studio

Android Studio Live Templates

Collection of my personal Live Templates for Android Studio / Intellij IDEA.

Download or clone this repository and copy all the files inside templates directory to your AndroidStudio’s config/templates folder

Note: If you are using Android Studio, then you will find AndroidStudio folder name instead of IntelliJ IDEA

Restart and done! #Awesome

Here is the list of codes available, try them out!

Many of the templates uses data binding for faster development.

XML Layout Templates

Currently following live templates are supported for Kotlin which we are used to in Java

Have an idea or live template which can be useful? Share it by creating an issue or submitting a pull request.

Using Studio Templates

Copy the folders inside studio_templates to

Currently available templates:

• New Activity with databinding (auto-enable databinding)
• Add dependecies on the fly

About

A collection of Android Studio Live Templates for the lazy developers

Источник

Android Studio Live Templates

Android Studio Live Templates

Code completion can improve your productivity by reducing how much you have to type, but there are situations when a more powerful tool is needed. Thanks to Android Studio and IntelliJ, live templates make it much easier to focus on just the things you care about.

Live Templates

Live Templates are code snippets that I can insert into my code by typing their abbreviation and pressing tab . They live in the Editor section of the Preferences.

A template contains hard-coded text and placeholder tokens (or variables). The parts that are marked by the $ character on either end are variables and normally would be the things that I’d be expected to type in.

For example, one of the built-in templates looks like this:

Here, we have three variables $INDEX$ , $LIMIT$ and $END$ .

• $END$ is a special predefined variable that controls where your cursor will be placed once you’re done filling out the template. We will have to fill out the values of the other two.
• To use this template, I will type fori in the Java file and press tab . Android Studio will expand the template and put the cursor on the first variable that needs to be replaced. In this case, it will put the cursor where the template has the $INDEX$ token.
• As I type something, the other two places where $INDEX$ appears will copy what I’m typing, live!
• When I’m done naming the index variable, I will press tab or return and the cursor will move to the next variable that needs to be defined, which is $LIMIT$ .
• Finally, after I finish typing in the $LIMIT$ variable, pressing tab or return will place the cursor where the $END$ variable is and will stop the template fill-out session.

Templates in Action

Let’s look at a more complex example.
In our Android Programming Guide, we use the newIntent pattern for Activities and the newInstance pattern for Fragments. Typically, creating a new Activity/Fragment pair involves the following steps:

• Create the newIntent method in the activity.
• Create the constant(s) for the names of extras to be passed with the Intent .
• Create the getFragment method that reads the Intent extras and passes them on to the fragment’s newInstance method.
• Create the newInstance method in the fragment.
• Create the constant(s) for the names of the arguments to be set on the fragment.
• Create the instance variable(s) to store the values of the arguments.
• Read the arguments in the onCreate method.

In this video, I demonstrate how live templates make it much easier to focus on just the things I care about, rather than the boilerplate.

In the first part of the video, I’m using my “Activity New Intent with Arguments” template. I type ania , the abbreviation I assigned to it, then hit so Android Studio expands the template, and then I type these characters: String scannerId . I end up with this code:

I have another template, “Fragment New Instance with Arguments.” I type the abbreviation I assigned to the template, fnia , then , and get the expanded template. Then I type the same sequence of characters as for the ania template: String scannerId . This is the result:

Not too bad for just under 30 keystrokes.

Creating Templates

There are two parts to live templates. One is the template itself and the other is the definition of the variables. This is my ania live template:

Note that variables are deliniated by the $ symbol. Normally, each variable is what you need to type in. If a variable appears in multiple places, all of them are updated simultaneously as you type. It’s possible to customize these variables and even to automatically set their values based on other variables.

For example, $CLASS_NAME$ is defined as expression className , which evaluates to the name of the current class. Here’s the full list of definitions:

Name	Expression	Default Value	Skip if Defined
EXTRA_CLASS	typeOfVariable(VAR)	[ ]
EXTRA_VAR	suggestVariableName	[ ]
CLASS_NAME	className	[x]
EXTRA_PARAM	capitalizeAndUnderscore(EXTRA_VAR)	[x]
FRAGMENT_CLASS	groovyScript(«_1.replaceAll(‘Activity’,’Fragment’)», CLASS_NAME)	[x]

Three of the variables are marked “Skip if defined,” so I don’t need to type them; their names are derived from what I have already typed. I can even use groovyScript to evaluate expressions beyond the fairly rich predefined set.

As I noted earlier, $END$ controls where your cursor will be once you’re done filling out the template. In this example, I want to put it inside the newIntent method just before the return statement, so that I can customize the Intent object further. For example, I could add flags or more extras.

The fnia template is very similar:

I had to use a little trick in this template. I created a special variable, $ARG_CLASS_DITTO$ . that’s a copy of the $ARG_CLASS$ variable. The reason I duplicated them is to force the cursor to start at the type of the parameter of the newInstance method. If I didn’t do this, the cursor would first jump to the type of the instance variable, then to the name of the parameter.

Thanks to live templates, I’ve reduced the amount of typing I have to do when creating new Activities and Fragments. Of course, there are many other situations where Live Templates would come in handy as well. I’m sure lots of you have your own productivity tips and examples of Live Templates, so please feel free to share with your fellow developers in the comments!

Источник