This action might not be possible to undo. Are you sure you want to continue?
IntelliJ IDEA supports development of applications to be executed on mobile phones that run under the Android operating system. Besides general coding assistance, the IDE lets you test Android applications on user-configured emulators of physical devices. IntelliJ IDEA helps:
Create an Android application using the New Project Wizard. Explore an Android application as a tree-view of files and folders. Create elements of an Android application and manage static content resources, such as strings, colors, etc. via tight integration between resources and the R.java file. Run an application. Configure an emulator of a physical device to run Android applications on.
This tutorial will walk you step-by-step through developing and launching a simple Android application.
You are working with IntelliJ IDEA Ultimate edition version 10.5 or higher. Java SDK (JDK) and Android SDK are installed on your machine. This tutorial uses SDK 3.1.
Creating a New Project
Let’s start from the very beginning and create a project for our application. Choose File | New Project on the main menu or click the Create New Project icon on the Welcome screen (Image 1).
Image 1. On the first page of the New Project wizard (Image 2), make sure that the option Create project from scratch is selected.
On the second page of the wizard (Image 3). choose the parent folder (1) to create the project in and specify the name of the project (2). Image 3. . Select the Create module check box (3) and choose Android Module (4) as the module type. By default. As you type the project name. IntelliJ IDEA updates the path to the location of the project files accordingly. The name of our project and module will be android_hello_world. the module will have the same name (5) as the project.
you still need a JDK because IntelliJ IDEA uses it in compilation. even if you have several of them on your computer. . we’ll integrate IntelliJ IDEA with the Android SDK and specify the target Android platform for which the application is intended.5 considers the Android platform itself as the project/module SDK. IntelliJ IDEA 10. Previously. while the JDK played the role of the main project/module SDK. When you are creating a project for the first time after IntelliJ IDEA installation. you could configure an Android SDK inside the Android module facet settings. choose the Create source directory option (1) and accept the default name src (2) for it.On the third page of the wizard (Image 4). Image 4. Besides an Android SDK. This means that IntelliJ IDEA does not know the location of any Android SDK or Java SDK home directories. IntelliJ IDEA displays the full path to the src folder (3) for your information. Configuring Android SDK and Java SDK On the fourth page of the wizard (Image 5). click the Browse button (1) next to the Android SDK drop-down list. no Android or Java SDKs are configured at the IDE level yet. To configure a Java SDK and an Android SDK at the IDE level.
Click the Configure button and specify the location of the desired JDK in the Select Home Directory for JSDK dialog box that opens. The specified JDK is now available at the IDE level. you return to the wizard where the selected JDK is listed as the Project JDK. In the Configure SDK dialog box that opens (Image 6). Configuring Java SDK Let’s first configure a Java SDK. IntelliJ IDEA will treat this JDK as the default project JDK for any new project and will not bring you to this page anymore. Image 5. click the Add toolbar button (1) and choose JSDK (2) from the list: . When you click OK.
specify the folder where the relevant version of Java SDK is located (1): Image 7.Image 6. . In the Select Home Directory for JSDK dialog box (Image 7).
Configuring Android SDK Click the Add toolbar button (1) again. . This time. choose Android SDK (2) from the list (Image 9): Image 9. you return to the Configure SDK dialog box (Image 8).Upon clicking OK (2). where the selected JDK is already on the list (1): Image 8.
so the list contains only one item (1). IntelliJ IDEA asks you to specify which version of Java SDK (JDK) configured at the IDE level you want to use in this project (Image 11): Image 11.In the Select Home Directory for Android SDK dialog box (Image 10) that opens. We have just configured the first JDK after IntelliJ IDEA installation. When you click OK (2). . specify the folder where the relevant version of Android SDK is located (1): Image 10. Just click OK.
Upon clicking OK. you return to the Configure SDK dialog box (Image 13).1 (1): Image 12. select the Android target platform.In the dialog box that opens (Image 12). IntelliJ IDEA has detected and recognized the newly configured Android SDK (1): . Choose Android 3. Click OK (3). As you can see. where both new SDK configurations – the Java SDK (1) and the Android SDK (2) – are on the list: Image 13. At last we are back to the fourth page of the wizard (Image 14). This is the Android platform for running on which your application will be intended.
. Completing Project Creation Now let’s specify some additional set-up parameters for our project (Image 15).Image 14. Image 15.
To have the data automatically arranged so the compiled application completely fits the selected platform. and configure the Android SDK as described above. 2. select the Create default Android application structure check box (1). we’ll use the Project tool window (Image 16) that shows the following files and folders: . let’s look deeper into its structure.1. Select the Application (2) project type. Exploring an Android Application To explore our application. Accept the suggested application name (3) and package (4). We are not going to share the module resources with other modules so there is no need to declare it as library project. IntelliJ IDEA creates a project and generates the skeleton of our application. that opens. When you click Finish (7). select the Create “Hello. the click the SDKs node in the Project Structure dialog box. World!” activity check box (5) and accept the suggested activity name MyActivity (6). First. Note: If you still have not configured an Android SDK yet. you can do it right now. To have a sample application created. 3. 4. Choose File | Project Structure on the main menu.
The src (2) folder contains the MyActivity. . The file belongs to the com.Image 16 The . The res (4) folder contains various visual resources. The layout/main.idea (1) folder contains a number of subfolders.example package.java (3) file source code that implements the functionality of your application. mainly with internal IntelliJ IDEA information.xml file (5) defines the appearance of the application constituted of resources of various types.
The drawable folders contain images (7). The main.java (9) file that links the visual resources and the Java source code. Image 17. As you will see from the Adding a Color section. the layout folder can also contain. IntelliJ IDEA supports tight integration between static resources and R. .xml files that describe resources of various types. the corresponding classes and class fields in R. The values folder (6) is intended for storing .java. a descriptor of colors. position the caret at the reference (2) and press Ctrl+B. The gen (8) folder contains the R.xml file with String resources definitions.xml file (4) opens. the folder contains a strings.java file also belongs to the com. Presently. The R.java (1) just references the layout/main.xml file (4) that defines the application appearance.java are automatically generated or removed accordingly. As you can see from Image 17. MyActivity. Creating Elements of Your Application To illustrate the mainstream Android development workflow in IntelliJ IDEA. for example. As soon as any resources are added or removed. As you can see. Let’s also define the color in which the explanation text will be displayed on the screen.example package. let’s expand the stub “Hello world!” application with a piece of text to explain the main goals of the application. the source code of MyActivity. the text to be displayed is Hello World. To navigate to the referenced code. As you will see from the sections below.
But IntelliJ IDEA also suggests a quick fix for the problem: just press Alt+Enter or click the red bulb (1).xml file where a new empty string definition is added to the list (Image 20). IntelliJ IDEA opens the strings.xml option (2) from the list (Image 19): Image 19. IntelliJ IDEA reports an unresolved reference and highlights it red. Adding a String In the main.xml file. . Image 18. then choose Create resource explanation in strings.We need to add two things to the application layout: an explanation string and a color to display it. place the following piece of code inside the <LinearLayout /> tag: <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/explanation" /> As you can see (Image 18).
Type the application description inside the <string /> tag.java file (3) opens. with the new string added to the list of string resources (4) and the cursor positioned at this new resource: Image 21. right click the values folder (1) and choose New (2) | Values resource file (3) on the context menu. we will create a color resource file with a string_color definition (Image 22). . the R. Adding a Color Now let’s define the color to display the explanation string. specify color as the new file name (4). In the New values resource file dialog that opens. If you click the Go to resource button (2) in the left gutter area.xml file (1). Image 21 illustrates the updated source code of the strings. for example: This simple Android application illustrates the mainstream Android development workflow in IntelliJ IDEA. To do that.Image 20. In the project tree.
.Image 22. IntelliJ IDEA displays the new file in the project tree (Image 23): Image 23. When you click OK.
type the color definition in the form: <color name="string_color">hexadecimal identifier of the desired color prepended with #</color> In our example (Image 24). let’s apply the new color to the explanation string. the new resource definition is automatically reflected in R.xml file in the editor by double-clicking it in the Project tool window. IntelliJ IDEA shows the preview of the specified color (2) in the left gutter area: Image 24. Inside the <resources /> tag. Now. let’s add a string_color resource definition.xml file. locate the following <TextView /> item: <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/explanation" . As you might have guessed.java (Image 25): Image 25. Open the color. In the main. As you type the color definition (1).Now. the hexadecimal identifier is #ff00ff77.
choose Edit Configurations (1). This device will emulate execution of the application on the target physical device. To launch the application straight away. IntelliJ IDEA has already selected the module hello_world(2) to apply the configuration to and the activity to launch (3). As you can see. . Running Android Application During the project creation. Configuring a Virtual Android Device From the Run/Debug Configuration (Image 26) drop-down list on the toolbar. IntelliJ IDEA opens the Run/Debug Configurations dialog box (Image 27) that shows the details of the default android_hello_world run configuration (1). we only need to configure a virtual device to run it on. Image 26. Make sure the Deploy application check box (4) is selected and the Choose target device manually check box (5) is cleared. IntelliJ IDEA has generated the default run configuration android_hello_world./> and add the following code inside it below android:text="@string/explanation": android:textColor="@color/string_color" That’s all with developing the sources of our application.
1 as the target platform (2): . Click the Browse button next to the Prefer Android Virtual Device for Deployment drop-down list (6).Image 27. The Create Android Virtual Device dialog box (Image 20) opens. click Create: Image 28. In the Select Android Virtual Device dialog box (Image 28) that opens. Accept the suggested device name MyAvd0 (1) and Android 3.
where the Prefer Android Virtual Device for Deployment drop-down list (1) now shows the emulator you’ve defined. IntelliJ IDEA brings you to the Select Android Virtual Device dialog box (Image 30). When you click OK. Click OK to save the settings and return to the Run/Debug Configurations dialog box (Image 31). Image 30.Image 29. where the virtual device you’ve defined is already added to the list and selected. . The target platform must be the one appointed during the module Android SDK configuration.
let’s launch our application. during the first application start. Moreover. IntelliJ IDEA remembers this virtual device at the IDE level so you can use it for running other applications.Image 31. Image 32. On the toolbar (Image 32). click (2) next to the Run/Debug Configuration (1) dropdown list where the android_hello_world run configuration is already selected by default. Complete the configuration definition settings by clicking OK. you need to configure a virtual device only once. IntelliJ IDEA will use it by default when you start your application with the android_hello_world run configuration. IntelliJ IDEA launches the configured emulator (Image 33) and deploys the Hello world application on it: . Start Application Now that we are through with all the preliminary steps. Fortunately.
Image 33. Click the lock symbol twice to have the application output displayed (Image 34): Image 34. .
Related Articles Developing Android applications on the base of existing sources Developing for Android in IntelliJ IDEA .Congratulations! You have developed and launched a simple Android application.
This action might not be possible to undo. Are you sure you want to continue?
We've moved you to where you read on your other device.
Get the full title to continue reading from where you left off, or restart the preview.