JetBrains IntelliJ IDEA Blog

In IntelliJ IDEA 11 we’ve improved Android logcat view, so now watching the logs of your applications became much more convenient.

First, you can create your own named filters and switch between them:

You can use regular expressions to filter the log, e.g. by a tag or message text. Note that autocompletion of tags already presented in the log is available: 

Another noteworthy improvement is that multiline messages aren’t cut anymore when you filter them by a named filter or using search. For example, if you search for “ActivityThread.java”, you’ll see full stacktrace containing the query, but not just separate lines: 

IntelliJ IDEA 11 introduces a new feature that makes it much easier to design UI layouts for Android applications — UI layouts preview. Just open some layout xml file from your Android project and you’ll see a new Preview tool window. 

Preview is updated as you edit the file, so you can see the changes immediately. Many different options such as screen size, target platform version, theme, etc. are available for tuning what you see.

Custom view components are also supported and shown correctly. But since IntelliJ IDEA uses class files from your output directory to render such components, you have to build your project first.

Please note, that layout preview feature is under development, so we really need to know your opinions. You’re welcome to try it in the latest Nika EAP and let us know what you think. If the IDE doesn’t preview some of your layout xml files, please submit bugreports with these files attached.

Recently, we’ve introduced a new feature that should make it MUCH easier to debug your Android applications. Now, you can attach IntelliJ IDEA debugger to any process running on an Android device or in the emulator, which is related to the source code of your project.

Just click “Attach debugger to Android process” toolbar button and you’ll see the list of processes grouped by device they are running on:

Note: to be shown in the list above the name of the process should be specified in AndroidManifest.xml as a “package” or “process” XML attribute.

The feature is, of course, available in the IntelliJ IDEA 10.5 Release Candidate. So, you are welcome to try and let us know what you think.

Recently we’ve added a new code highlighting feature that should make it easier to work with big and complex HTML files, with deep nested tags structure:

Please note that highlighting is only activated when there is more than one tag with the same name in the hierarchy.

By default, only 6 parent tags are highlighted with 6 different colors. You can change the depth to highlight or completely disable the feature in Settings | Editor | Appearance | Enable HTML tag tree highlighting.

Also you can tweak the colors in Settings | Colors & Fonts | HTML.

This feature is very new and we want your opinions. You are welcome to try it in the latest IntelliJ IDEA 10.5 EAP build and let us know what you think.

The recent EAP of IntelliJ IDEA 10.5 introduces a new presentation of Android platform inside a project.

Previously, you could configure Android SDK inside Android facet settings, while JDK played the role of the main Project/Module SDK. IntelliJ IDEA 10.5 considers Android platform itself as a Project/Module SDK:

Thus, the standard JDK jars aren’t included to the classpath of your Android module. So, the IDE will not complete the java classes which are not supported by the Android platform anymore. Also, the usages of such classes will be correctly highlighted as errors:

Note, that in addition to the Android SDK, you still need a Java SDK because IntelliJ IDEA uses it for compilation. You’ll be prompted for it while creating a new Android SDK.

It is important to mention that once you open an existing Android project in IntelliJ IDEA 10.5 it will be converted automatically, no manual configuration needed.

You are welcome to try it in the latest IntelliJ IDEA 10.5 EAP build and let us know what you think.

An Android library project is a development project that holds shared Android source code and resources. Other Android application projects can reference the library project and, at build time, include its compiled sources in their .apk files. IntelliJ IDEA X supports library projects natively as separate Android library modules.

To create a new library module you need to choose a platform and specify a package:

Application module has to depend on library modules to refer to their resources and source code. Scope of this dependency should be Compile. You can refer to library resources from your application module, as they are located in the same module. Note that you can change a module type (Application or Library) in Android facet settings:

With IntelliJ IDEA X you can write unit tests for your Android application using Android Testing Framework. Android unit tests are located in a separate test module, so first you need to add it (i.e. named tests) to your project, which must already contain an Android module (or module with Android facet) (i.e. named MyAndroidApp). Then, specify this tested module:

IntelliJ IDEA will automatically create a sample test class for your main activity (i.e. MyActivityTest). It’s handy that you can launch tests directly from editor. Note that it is important to choose an item with Android-specific icon for launching tests by Android Tests run configuration rather than using a default JUnit configuration:

Also, after adding a test module to project, IntelliJ IDEA automatically creates run configuration for launching all tests in module:

Note, that scope of a dependency between Test module and Application module should be Provided.

With IntelliJ IDEA 9.0.2 you can edit HTML and CSS code really fast using Zen Coding features. To use it, you have to install Zen Coding plugin for Web IDE/IntelliJ IDEA: go to Zen Coding Project Download Page, download an archive that contains a set of live templates, and extract it to “<Your Home Directory>\.IntelliJIdea90\config\templates” folder (”~/Library/Preferences/IntelliJIDEA90/templates” for Mac OS X).

• Zen Coding plugin involves more than 200 different HTML and CSS live templates. To see all of them, just open Settings (Ctrl+Alt+S), Live Templates, Zen Coding group.

• Native Zen Coding support allows you to generate HTML structures using complex templates. For example, try to type “form.form-comment#comment>fieldset” in an HTML file and then press TAB. In this case, “form” and “fieldset“ are live templates but you can use simple tag names instead.

• You can generate not only HTML but also XML structures. Basic features perfectly work for XML.

• “TAG.CLASS” and “TAG#ID” templates allow you to specify class and id of HTML elements, but you can specify a value of any XML/HTML attribute, i.e. you can write “person[name=Jack]“.

• You can use your own live templates as parts of complex templates. For example, suppose you have a template “entry” with the following template text: To generate a list of entries, you just need to type “entry-list>entry[number=$]*5″ and press TAB. By default, the “number” attribute will be generated before “type”. If you want to customize the position where it’s generated, add ATTRS variable to your template – for example: ATTRS variable must have empty string as a default value and should be skipped:

• Of course, you can disable Zen Coding support if you don’t need it (see Settings (Ctrl+Alt+S), XML Zen Coding).

To learn more about Zen Coding features, you can watch screencasts on Zen Coding project home page. Note that Zen Coding native support is a part of IDEA Community Edition, and its source code is freely available.

Editing CSS files in Flex applications becomes easier with the help of some new Maia features.

First, completion for CSS selectors, properties, and property values. For example, if you press Ctrl+Space in this context, you get all class names from
a default namespace http://www.adobe.com/2006/mxml + global selector:

If a CSS property has a color format, IntelliJ IDEA helps you to select a color:

(more…)

In Maia you can find a new Android Logcat window that lets you see all log messages and exceptions when you are debugging an Android application.

The Logging level list allows you to select what messages are displayed in console:

• Verbose — lowest priority, all messages
• Debug
• Info
• Warning
• Error
• Fatal
• Assert — highest priority, assertions only.

Logcat supports stack trace navigation and messages highlighting (you can customize colors for various log levels in the IDE Settings dialog (Ctrl+Alt+S). Note that Logcat is available only in debug mode.