From 8c068aeee06efd2ce0827c81e5919e90358c56e3 Mon Sep 17 00:00:00 2001 From: Scott Rowe Date: Mon, 19 May 2014 16:50:47 -0700 Subject: docs: Training refactor for Android Studio Cherrypick from lmp-docs hange-Id: I4c396b1a6b689a32b5a3328e9948f363ebb1e37d, from lmp-dev Change-Id: I830da649d9fac2b87eff5ee5cfc3422d5ab65ffc, Cherrypick from klp-modular-docs Change-Id: Ifaae51e4fa3afbef3d81d260135fd348a6ccb612 Change-Id: I09a9473d73eb9c27ee6966b2a0e1cd736575db06 --- docs/html/training/basics/firstapp/building-ui.jd | 254 ++++++++------ .../training/basics/firstapp/creating-project.jd | 212 +++++++----- docs/html/training/basics/firstapp/index.jd | 18 +- docs/html/training/basics/firstapp/running-app.jd | 181 ++++------ .../training/basics/firstapp/starting-activity.jd | 370 ++++++++++++--------- 5 files changed, 575 insertions(+), 460 deletions(-) (limited to 'docs/html/training/basics') diff --git a/docs/html/training/basics/firstapp/building-ui.jd b/docs/html/training/basics/firstapp/building-ui.jd index c082642..2668913 100644 --- a/docs/html/training/basics/firstapp/building-ui.jd +++ b/docs/html/training/basics/firstapp/building-ui.jd @@ -8,9 +8,9 @@ helpoutsWidget=true -
-
- +
+
+

This lesson teaches you to

    @@ -27,16 +27,18 @@ helpoutsWidget=true
  1. Layouts
    2. -
-
- +
+
+

In this lesson, you create a layout in XML that includes a text field and a +button. In the next lesson, your app responds when the button is pressed by sending the +content of the text field to another activity.

The graphical user interface for an Android app is built using a hierarchy of {@link android.view.View} and {@link android.view.ViewGroup} objects. {@link android.view.View} objects are usually UI widgets such as buttons or -text fields and {@link -android.view.ViewGroup} objects are +text fields. +{@link android.view.ViewGroup} objects are invisible view containers that define how the child views are laid out, such as in a grid or a vertical list.

@@ -44,6 +46,8 @@ grid or a vertical list.

android.view.View} and {@link android.view.ViewGroup} so you can define your UI in XML using a hierarchy of UI elements.

+

Layouts are subclasses of the {@link android.view.ViewGroup}. In this exercise, you'll work with +a {@link android.widget.LinearLayout}.

@@ -63,33 +67,32 @@ Devices.

android.view.ViewGroup} objects form branches in the layout and contain other {@link android.view.View} objects.

-

In this lesson, you'll create a layout in XML that includes a text field and a -button. In the following lesson, you'll respond when the button is pressed by sending the -content of the text field to another activity.

- -

Create a Linear Layout

-

Open the fragment_main.xml file from the res/layout/ -directory.

- -

Note: In Eclipse, when you open a layout file, you’re first shown -the Graphical Layout editor. This is an editor that helps you build layouts using WYSIWYG tools. For this -lesson, you’re going to work directly with the XML, so click the fragment_main.xml tab at -the bottom of the screen to open the XML editor.

- +
    +
  1. In Android Studio, from the res/layout directory, open the activity_my.xml +file.

    The BlankActivity template you chose when you created this project includes the -fragment_main.xml file with a {@link -android.widget.RelativeLayout} root view and a {@link android.widget.TextView} child view.

    +activity_my.xml file with a {@link android.widget.RelativeLayout} root view and a +{@link android.widget.TextView} child view.

    +
    2. +
  2. In the Preview pane, click the Hide icon to close the Preview pane. +

    In Android Studio, when you open a layout file, you’re first shown + the Preview pane. Clicking elements in this pane opens the WYSIWYG tools in the Design pane. For + this lesson, you’re going to work directly with the XML.

    3. +
  3. Delete the {@link android.widget.TextView <TextView>} element.
    4. +
  4. Change the {@link android.widget.RelativeLayout <RelativeLayout>} element to +{@link android.widget.LinearLayout <LinearLayout>}.
    5. +
  5. Add the +{@code android:orientation} attribute and set it to "horizontal".
    6. +
  6. Remove the {@code android:padding} attributes and the {@code tools:context} attribute. +
-

First, delete the {@link android.widget.TextView <TextView>} element and change the {@link - android.widget.RelativeLayout <RelativeLayout>} element to {@link - android.widget.LinearLayout <LinearLayout>}. Then add the -{@code -android:orientation} attribute and set it to "horizontal". -The result looks like this:

+

The result looks like this:

+

res/layout/activity_my.xml

 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
@@ -104,9 +107,9 @@ android.view.ViewGroup}) that lays out child views in either a vertical or horiz
 as specified by the {@code
 android:orientation} attribute. Each child of a {@link android.widget.LinearLayout} appears on
-the screen in the order in which it appears in the XML.
 
+the screen in the order in which it appears in the XML.

 
-
The other two attributes, Two other attributes, {@code
 android:layout_width} and {@code
@@ -122,28 +125,47 @@ or height to match the width or height of the parent view.

 href="{@docRoot}guide/topics/ui/declaring-layout.html">Layout guide.

 
 
-
 
Add a Text Field

 
-
To create a user-editable text field, add an {@link android.widget.EditText
-<EditText>} element inside the {@link android.widget.LinearLayout <LinearLayout>}.

+
As with every {@link android.view.View} object, you must define certain XML attributes to specify
+the {@link android.widget.EditText} object's properties.

+
+
    
+
  1. In the activity_my.xml file, within the
+{@link android.widget.LinearLayout <LinearLayout>} element, define an
+{@link android.widget.EditText <EditText>} element with the id attribute
+set to @+id/edit_message.
    2. 
+
  2. Define the layout_width and layout_height attributes as
+wrap_content.
    3. 
+
  3. Define a hint attribute as a string object named edit_message.
    4. 
+

 
-
Like every {@link android.view.View} object, you must define certain XML attributes to specify
-the {@link android.widget.EditText} object's properties. Here’s how you should declare it
-inside the {@link android.widget.LinearLayout <LinearLayout>} element:

+
The {@link android.widget.EditText <EditText>} element should read as follows:

 
+
res/layout/activity_my.xml

 
-    <EditText android:id="@+id/edit_message"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:hint="@string/edit_message" />
+<EditText android:id="@+id/edit_message"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:hint="@string/edit_message" />
 

 
+
Here are the {@link android.widget.EditText <EditText>} attributes you added:

+
+

+
{@code android:id}

+
This provides a unique identifier for the view, which you can use to reference the object
+from your app code, such as to read and manipulate the object (you'll see this in the next
+lesson).
+
+
The at sign (@) is required when you're referring to any resource object from
+XML. It is followed by the resource type ({@code id} in this case), a slash, then the resource name
+({@code edit_message}).

 
 

 

-  
About resource objects

-  
A resource object is simply a unique integer name that's associated with an app resource,
+  
Resource Objects

+  
A resource object is a unique integer name that's associated with an app resource,
 such as a bitmap, layout file, or string.

   
Every resource has a
 corresponding resource object defined in your project's {@code gen/R.java} file. You can use the
@@ -153,30 +175,18 @@ href="{@docRoot}reference/android/widget/TextView.html#attr_android:hint">{@code
 attribute. You can also create arbitrary resource IDs that you associate with a view using the {@code android:id} attribute,
 which allows you to reference that view from other code.

-  
The SDK tools generate the {@code R.java} each time you compile your app. You should never
+  
The SDK tools generate the {@code R.java} file each time you compile your app. You should never
 modify this file by hand.

   
For more information, read the guide to Providing Resources.

 

 

 
-
About these attributes:

-
-

-
{@code android:id}

-
This provides a unique identifier for the view, which you can use to reference the object
-from your app code, such as to read and manipulate the object (you'll see this in the next
-lesson).
-
-
The at sign (@) is required when you're referring to any resource object from
-XML. It is followed by the resource type ({@code id} in this case), a slash, then the resource name
-({@code edit_message}).

-
 
The plus sign (+) before the resource type is needed only when you're defining a
 resource ID for the first time. When you compile the app,
 the SDK tools use the ID name to create a new resource ID in
 your project's {@code gen/R.java} file that refers to the {@link
-android.widget.EditText} element. Once the resource ID is declared once this way,
+android.widget.EditText} element. With the resource ID declared once this way,
 other references to the ID do not
 need the plus sign. Using the plus sign is necessary only when specifying a new resource ID and not
 needed for concrete resources such as strings or layouts. See the sidebox for
@@ -209,26 +219,25 @@ the same name does not cause collisions.

 

 

 
-
-
 
Add String Resources

 
-
When you need to add text in the user interface, you should always specify each string as
-a resource. String resources allow you to manage all UI text in a single location,
-which makes it easier to find and update text. Externalizing the strings also allows you to
-localize your app to different languages by providing alternative definitions for each
-string resource.

-
 
By default, your Android project includes a string resource file at
-res/values/strings.xml. Add a new string named
-"edit_message" and set the value to "Enter a message." (You can delete
-the "hello_world" string.)

+res/values/strings.xml. Here, you'll add a new string named
+"edit_message" and set the value to "Enter a message."

 
-
While you’re in this file, also add a "Send" string for the button you’ll soon add, called
-"button_send".

+
    
+
  1. In Android Studio, from the res/values directory, open strings.xml.
    2. 
+
  2. Add a line for a string named "edit_message" with the value, "Enter a message".
+
    3. 
+
  3. Add a line for a string named "button_send" with the value, "Send".
+
    You'll create the button that uses this string in the next section.
    
+
    4. 
+
  4. Remove the line for the "hello world" string.
    5. 
+

 
 
The result for strings.xml looks like this:

 
+
res/values/strings.xml

 
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
@@ -240,35 +249,59 @@ the "hello_world" string.)

 </resources>
 

 
+
For text in the user interface, always specify each string as
+a resource. String resources allow you to manage all UI text in a single location,
+which makes the text easier to find and update. Externalizing the strings also allows you to
+localize your app to different languages by providing alternative definitions for each
+string resource.

+
 
For more information about using string resources to localize your app for other languages,
 see the Supporting Different Devices
 class.

 
 
-
-
 
Add a Button

 
-
Now add a {@link android.widget.Button <Button>} to the layout, immediately following the
-{@link android.widget.EditText <EditText>} element:

+
    
+
  1. In Android Studio, from the res/layout directory, edit the activity_my.xml
+file.
    2. 
+
  2. Within the
+{@link android.widget.LinearLayout <LinearLayout>} element, define a
+{@link android.widget.Button <Button>} element immediately following the
+{@link android.widget.EditText <EditText>} element.
    3. 
+
  3. Set the button's width and height attributes to "wrap_content" so
+the button is only as big as necessary to fit the button's text label.
    4. 
+
  4. Define the button's text label with the {@code
+android:text} attribute; set its value to the button_send string
+resource you defined in the previous section.
    5. 
+

+
+
Your {@link android.widget.LinearLayout <LinearLayout>} should look like this:

 
+
res/layout/activity_my.xml

 
-    <Button
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="horizontal" >
+      <EditText android:id="@+id/edit_message"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:text="@string/button_send" />
+        android:hint="@string/edit_message" />
+      <Button
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/button_send" />
+</LinearLayout>
 

 
-
The height and width are set to "wrap_content" so the button is only as big as
-necessary to fit the button's text. This button doesn't need the 
+
Note: This button doesn't need the
 {@code android:id}
 attribute, because it won't be referenced from the activity code.

 
-
-
-
Make the Input Box Fill in the Screen Width

-
 
The layout is currently designed so that both the {@link android.widget.EditText} and {@link
 android.widget.Button} widgets are only as big as necessary to fit their content, as shown in
 figure 2.

@@ -279,7 +312,7 @@ android.widget.Button} widgets have their widths set to
 "wrap_content".

 
 
This works fine for the button, but not as well for the text field, because the user might type
-something longer. So, it would be nice to fill the unused screen width
+something longer. It would be nice to fill the unused screen width
 with the text field. You can do this inside a
 {@link android.widget.LinearLayout} with the weight property, which
 you can specify using the  attribute.

 
 
The weight value is a number that specifies the amount of remaining space each view should
 consume,
-relative to the amount consumed by sibling views. This works kind of like the 
+relative to the amount consumed by sibling views. This works kind of like the
 amount of ingredients in a drink recipe: "2
-parts vodka, 1 part coffee liqueur" means two-thirds of the drink is vodka. For example, if you give
+parts soda, 1 part syrup" means two-thirds of the drink is soda. For example, if you give
 one view a weight of 2 and another one a weight of 1, the sum is 3, so the first view fills 2/3 of
 the remaining space and the second view fills the rest. If you add a third view and give it a weight
 of 1, then the first view (with weight of 2) now gets 1/2 the remaining space, while the remaining
@@ -298,38 +331,49 @@ two each get 1/4.

 
 
The default weight for all views is 0, so if you specify any weight value
 greater than 0 to only one view, then that view fills whatever space remains after all views are
-given the space they require. So, to fill the remaining space in your layout with the {@link
-android.widget.EditText} element, give it a weight of 1 and leave the button with no weight.

+given the space they require.

+
+
Make the Input Box Fill in the Screen Width

+
+
To fill the remaining space in your layout with the {@link android.widget.EditText} element, do
+the following:

 
+
    
+
  1. In the activity_my.xml file, assign the
+{@link android.widget.EditText <EditText>} element's layout_weight attribute a value
+of 1.
    2. 
+
  2. Also, assign {@link android.widget.EditText <EditText>} element's layout_width
+attribute a value of 0dp.
+
+
    res/layout/activity_my.xml
    
 
    -    <EditText
-        android:layout_weight="1"
-        ... />
+<EditText
+    android:layout_weight="1"
+    android:layout_width="0dp"
+    ... />
 
    
 
-
    In order to improve the layout efficiency when you specify the weight, you should change the
+
    To improve the layout efficiency when you specify the weight, you should change the
 width of the {@link android.widget.EditText} to be
 zero (0dp). Setting the width to zero improves layout performance because using
 "wrap_content" as the width requires the system to calculate a width that is
 ultimately irrelevant because the weight value requires another width calculation to fill the
 remaining space.
    
-
    -    <EditText
-        android:layout_weight="1"
-        android:layout_width="0dp"
-        ... />
-
    
 
 
    Figure 3
 shows the result when you assign all weight to the {@link android.widget.EditText} element.
    
 
 
 
    Figure 3. The {@link android.widget.EditText} widget is
-given all the layout weight, so fills the remaining space in the {@link
+given all the layout weight, so it fills the remaining space in the {@link
 android.widget.LinearLayout}.
    
 
-
    Here’s how your complete layout file should now look:
    
+
    3. 
+

 
+
Here’s how your complete activity_my.xmllayout file should now look:

+
+
res/layout/activity_my.xml

 
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
@@ -349,13 +393,16 @@ android.widget.LinearLayout}.

 </LinearLayout>
 

 
+
Run Your App

+
 
This layout is applied by the default {@link android.app.Activity} class
-that the SDK tools generated when you created the project, so you can now run the app to see the
+that the SDK tools generated when you created the project. Run the app to see the
 results:

 
 
    
-  
  • In Eclipse, click Run  from the toolbar.
    • 
+  
  • In Android Studio, from the toolbar, click Run
+    .
    • 
   
  • Or from a command line, change directories to the root of your Android project and
 execute:
 
    @@ -364,7 +411,8 @@ adb install bin/MyFirstApp-debug.apk
 
    • 
 

 
-
Continue to the next lesson to learn how you can respond to button presses, read content
+
Continue to the next
+lesson to learn how to respond to button presses, read content
 from the text field, start another activity, and more.

 
 
diff --git a/docs/html/training/basics/firstapp/creating-project.jd b/docs/html/training/basics/firstapp/creating-project.jd
index 418eb68..f33f75f 100644
--- a/docs/html/training/basics/firstapp/creating-project.jd
+++ b/docs/html/training/basics/firstapp/creating-project.jd
@@ -17,7 +17,7 @@ next.link=running-app.html
 
This lesson teaches you to

 
 
    
-  
  1. Create a Project with Eclipse
    2. 
+  
  2. Create a Project with Android Studio
    3. 
   
  3. Create a Project with Command Line Tools
    4. 
 

 
@@ -38,97 +38,145 @@ app. The Android SDK tools make it easy to start a new Android project with a se
 default project directories and files.

 
 
This lesson
-shows how to create a new project either using Eclipse (with the ADT plugin) or using the
+shows how to create a new project either using Android Studio or using the
 SDK tools from a command line.

 
 
Note: You should already have the Android SDK installed, and if
-you're using Eclipse, you should also have the ADT
-plugin installed (version 22.6.2 or higher). If you don't have these, follow the guide to 
+Android Studio installed. If you don't have these, follow the guide to Installing the Android SDK before you start this
 lesson.

 
 
-
Create a Project with Eclipse

+
Create a Project with Android Studio

 
 
    
-  
  1. Click New  in the toolbar.
    2. 
-  
  2. In the window that appears, open the Android folder,
-  select Android Application Project, and click Next.
    3. 
-
-
    
-
-
    Figure 1. The New Android App Project wizard in Eclipse.
    
-
    
-
-  
  3. Fill in the form that appears:
+  
  4. In Android Studio, create a new project:
     
      
-      
    • Application Name is the app name that appears to users.
-          For this project, use "My First App."
      • 
-      
    • Project Name is the name of your project directory and the name visible in Eclipse.
      • 
-      
    • Package Name is the package namespace for your app (following the same
-rules as packages in the Java programming language). Your package name
-must be unique across all packages installed on the Android system. For this reason, it's generally
-best if you use a name that begins with the reverse domain name of your organization or
-publisher entity. For this project, you can use something like "com.example.myfirstapp."
-However, you cannot publish your app on Google Play using the "com.example" namespace.
      • 
-      
    • Minimum Required SDK is the lowest version of Android that your app supports,
-      indicated using the API level.
-        To support as many devices as possible, you should set this to the lowest version available
-        that allows your app to provide its core feature set. If any feature of your app is possible
-        only on newer versions of Android and it's not critical to the app's core feature set, you
-        can enable the feature only when running on the versions that support it (as
-        discussed in Supporting Different Platform Versions).
-        Leave this set to the default value for this project.
-      
      • 
-      
    • Target SDK indicates the highest version of Android (also using the
-      API level) with which you
-      have tested with your application.
-        
      As new versions of Android become available, you should
-      test your app on the new version and update this value to match the latest API level
-      in order to take advantage of new platform features.
      
-      
      • 
-      
    • Compile With is the platform version against which you will compile your app.
-        By default, this is set to the latest version of Android available in your SDK. (It should
-        be Android 4.1 or greater; if you don't have such a version available, you must install one
-        using the SDK Manager).
-        You can still build your app to
-support older versions, but setting the build target to the latest version allows you to
-enable new features and optimize your app for a great user experience on the latest
-devices.
      • 
-       
    • Theme specifies the Android UI style to apply for your app. You can leave
-       this alone.
      • 
+      
    • If you don't have a project opened, in the Welcome screen, click 
+        New Project.
      • 
+      
    • If you have a project opened, from the File menu, select New
+        Project.
      • 
     
    
-    
    Click Next.
    
   
    5. 
-  
  5. On the next screen to configure the project, leave the default selections and click
-  Next.
    6. 
-  
  6. The next screen can help you create a launcher icon for your app.
-    
    You can customize an icon in several ways and the tool generates an icon for all
-    screen densities. Before you publish your app, you should be sure your icon meets
-    the specifications defined in the Iconography
-    design guide.
    
-    
    Click Next.
    
-  
    7. 
-  
  7. Now you can select an activity template from which to begin building your app.
-    
    For this project, select BlankActivity and click Next.
    
+  
    
+    
+    
    Figure 1. Configuring a new project in Android Studio.
    
+  
    
+  
  8. Under Configure your new project, fill in the fields as shown in figure 1
+    and click Next.
+    
    It will probably be easier to follow these lessons if you use the same values as shown.
    
+    
      
+      
    • Application Name is the app name that appears to users.
+          For this project, use "My First App."
      • 
+      
    • Company domain provides a qualifier that will be appended to the package
+        name; Android Studio will remember this qualifier for each new project you create.
      • 
+      
    • Package name is the fully qualified name for the project (following the
+        same rules as those for naming packages in the Java programming language). Your package name
+        must be unique across all packages installed on the Android system. You can 
+        Edit this value independently from the application name or the company
+        domain.
      • 
+      
    • Project location is the directory on your system that holds the project
+        files.
      • 
+    
    
   
    9. 
-  
  9. Leave all the details for the activity in their default state and click
-    Finish.
    10. 
+  
  10. Under Select the form factors your app will run on, check the box for 
+    Phone and Tablet.
    11. 
+  
  11. For Minimum SDK, select API 8: Android 2.2 (Froyo).
+    
    The Minimum Required SDK is the earliest version of Android that your app supports,
+      indicated using the 
+      API level. To support as many devices as possible, you should set this to the lowest
+      version available that allows your app to provide its core feature set. If any feature of your
+      app is possible only on newer versions of Android and it's not critical to the app's core
+      feature set, you can enable the feature only when running on the versions that support it (as
+      discussed in 
+      Supporting Different Platform Versions).
    12. 
+  
  12. Leave all of the other options (TV, Wear, and Glass) unchecked and click Next.
    13. 
+  
    
+    
    
+      
    Activities
    
+      
    An activity is one of the distinguishing features of the Android framework. Activities
+        provide the user with access to your app, and there may be many activities. An application
+        will usually have a main activity for when the user launches the application, another
+        activity for when she selects some content to view, for example, and other activities for
+        when she performs other tasks within the app. See 
+        Activities for more information.
    
+    
    
+  
    
+  
  13. Under Add an activity to your project, select Blank Activity
+    and click Next.
    14. 
+  
  14. Under Describe the new activity for your project, leave the fields as they
+    are and click Finish.
    15. 
 

 
-
Your Android project is now a basic "Hello World" app that contains some default files.
-To run the app, continue to the next lesson.

-
-
+
Your Android project is now a basic "Hello World" app that contains some default files. Take a
+moment to review the most important of these:

+
+

+  
app/src/main/res/layout/activity_my.xml

+  
This is the XML layout file for the activity you added when you created the project with Android
+    Studio. Following the New Project workflow, Android Studio presents this file with both a text
+    view and a preview of the screen UI. The file includes some default settings and a TextView
+    element that displays the message, "Hello world!"

+  
app/src/main/java/com.mycompany.myfirstapp/MyActivity.java

+  
A tab for this file appears in Android Studio when the New Project workflow finishes. When you
+    select the file you see the class definition for the activity you created. When you build and
+    run the app, the {@link android.app.Activity} class starts the activity and loads the layout file
+    that says "Hello World!"

+  
app/src/res/AndroidManifest.xml

+  
The manifest file describes
+    the fundamental characteristics of the app and defines each of its components. You'll revisit
+    this file as you follow these lessons and add more components to your app.

+  
app/build.gradle

+  
Android Studio uses Gradle to compile and build your app. There is a build.gradle
+    file for each module of your project, as well as a build.gradle file for the entire
+    project. Usually, you're only interested in the build.gradle file for the module,
+    in this case the app or application module. This is where your app's build dependencies
+    are set, including the defaultConfig settings:
+    
    
+      
  • compiledSdkVersion is the platform version against which you will compile
+        your app. By default, this is set to the latest version of Android available in your SDK.
+        (It should be Android 4.1 or greater; if you don't have such a version available, you must
+        install one using the SDK Manager.)
+        You can still build your app to support older versions, but setting this to the latest
+        version allows you to enable new features and optimize your app for a great user experience
+        on the latest devices.
    • 
+      
  • applicationId is the fully qualified package name for your application that
+        you specified during the New Project workflow.
    • 
+      
  • minSdkVersion is the Minimum SDK version you specified during the New Project
+        workflow. This is the earliest version of the Android SDK that your app supports.
    • 
+      
  • targetSdkVersion indicates the highest version of Android with which you have
+        tested your application. As new versions of Android become available, you should
+        test your app on the new version and update this value to match the latest API level and
+        thereby take advantage of new platform features. For more information, read
+        Supporting Different
+          Platform Versions.
    • 
+    

+    
See Building Your Project with Gradle
+    for more information about Gradle.

+

+
+
Note also the /res subdirectories that contain the
+resources for your application:

+

+  
drawable-hdpi/

+    
Directory for drawable objects (such as bitmaps) that are designed for high-density
+    (hdpi) screens. Other drawable directories contain assets designed for other screen densities.
+    Here you'll find the ic_launcher.png that appears when you run the default app.

+  
layout/

+    
Directory for files that define your app's user interface like activity_my.xml,
+      discussed above, which describes a basic layout for the MyActivity class.

+  
values/

+    
Directory for other XML files that contain a collection of resources, such as
+      string and color definitions. The strings.xml file defines the "Hello world!" string that
+      displays when you run the default app.

+

+
+
To run the app, continue to the next lesson.

 
 
Create a Project with Command Line Tools

 
-
If you're not using the Eclipse IDE with the ADT plugin, you can instead create your project
+
If you're not using the Android Studio IDE, you can instead create your project
 using the SDK tools from a command line:

 
 
    
@@ -136,32 +184,32 @@ using the SDK tools from a command line:
    
   
  1. Execute:
 
    android list targets
    
 
    This prints a list of the available Android platforms that you’ve downloaded for your SDK. Find
-the platform against which you want to compile your app. Make a note of the target id. We
+the platform against which you want to compile your app. Make a note of the target ID. We
 recommend that you select the highest version possible. You can still build your app to
 support older versions, but setting the build target to the latest version allows you to optimize
 your app for the latest devices.
    
 
    If you don't see any targets listed, you need to
 install some using the Android SDK
-Manager tool. See Adding Platforms
-  and Packages.
    2. 
+Manager tool. See Adding SDK
+  Packages.
    
   
  2. Execute:
 
     android create project --target <target-id> --name MyFirstApp \
---path <path-to-workspace>/MyFirstApp --activity MainActivity \
+--path <path-to-workspace>/MyFirstApp --activity MyActivity \
 --package com.example.myfirstapp
 
    
-
    Replace <target-id> with an id from the list of targets (from the previous step)
+
    Replace <target-id> with an ID from the list of targets (from the previous step)
 and replace
 <path-to-workspace> with the location in which you want to save your Android
 projects.
    3. 
 

 
-
Your Android project is now a basic "Hello World" app that contains some default files.
-To run the app, continue to the next lesson.

-
 
Tip: Add the platform-tools/ as well as the
 tools/ directory to your PATH environment variable.

 
+
Your Android project is now a basic "Hello World" app that contains some default files.
+To run the app, continue to the next lesson.

+
 
 
 
diff --git a/docs/html/training/basics/firstapp/index.jd b/docs/html/training/basics/firstapp/index.jd
index ac8e64a..d5df0b7 100644
--- a/docs/html/training/basics/firstapp/index.jd
+++ b/docs/html/training/basics/firstapp/index.jd
@@ -15,9 +15,8 @@ helpoutsWidget=true
 
Dependencies and prerequisites
@@ -29,16 +28,19 @@ helpoutsWidget=true project and run a debuggable version of the app. You'll also learn some fundamentals of Android app design, including how to build a simple user interface and handle user input.

+

Set Up Your Environment

+

Before you start this class, be sure you have your development environment set up. You need to:

    -
  1. Download the Android SDK.
    2. -
  2. Install the ADT plugin for Eclipse (if you’ll use the Eclipse IDE).
    3. -
  3. Download the latest SDK tools and platforms using the SDK Manager.
    4. +
  4. Download the Android SDK.
    5. +
  5. Install Android Studio.
    6. +
  6. Download the latest SDK tools and platforms using the + SDK Manager.
-

Note: Make sure you install the most recent versions of the ADT -plugin and the Android SDK before you start this class. The procedures described in this class may +

Note: Make sure you install the most recent versions of Android +Studio and the Android SDK before you start this class. The procedures described in this class may not apply to earlier versions.

If you haven't already done these tasks, start by downloading the diff --git a/docs/html/training/basics/firstapp/running-app.jd b/docs/html/training/basics/firstapp/running-app.jd index 96b7172..50b4fea 100644 --- a/docs/html/training/basics/firstapp/running-app.jd +++ b/docs/html/training/basics/firstapp/running-app.jd @@ -11,9 +11,9 @@ helpoutsWidget=true -

-
- +
+
+

This lesson teaches you to

    @@ -28,85 +28,32 @@ helpoutsWidget=true
  1. Managing Virtual Devices
  2. Managing Projects
    3. - - -
-
+ + +
+

If you followed the previous lesson to create an Android project, it includes a default set of "Hello World" source files that allow you to immediately run the app.

-

How you run your app depends on two things: whether you have a real Android-powered device and -whether you're using Eclipse. This lesson shows you how to install and run your app on a -real device and on the Android emulator, and in both cases with either Eclipse or the command line -tools.

- -

Before you run your app, you should be aware of a few directories and files in the Android -project:

- -
-
AndroidManifest.xml
-
The manifest file describes -the fundamental characteristics of the app and defines each of -its components. You'll learn about various declarations in this file as you read more training -classes. -

One of the most important elements your manifest should include is the {@code <uses-sdk>} -element. This declares your app's compatibility with different Android versions using the {@code android:minSdkVersion} -and {@code android:targetSdkVersion} -attributes. For your first app, it should look like this:

-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" ... >
-    <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="19" />
-    ...
-</manifest>
-
-

You should always set the {@code android:targetSdkVersion} -as high as possible and test your app on the corresponding platform version. For more information, -read Supporting Different -Platform Versions.

- -
-
src/
-
Directory for your app's main source files. By default, it includes an {@link -android.app.Activity} class that runs when your app is launched using the app icon.
-
res/
-
Contains several sub-directories for app resources. Here are just a few: -
-
drawable-hdpi/
-
Directory for drawable objects (such as bitmaps) that are designed for high-density -(hdpi) screens. Other drawable directories contain assets designed for other screen densities.
-
layout/
-
Directory for files that define your app's user interface.
-
values/
-
Directory for other various XML files that contain a collection of resources, such as -string and color definitions.
-
-
-
- -

When you build and run the default Android app, the default {@link android.app.Activity} -class starts and loads a layout file -that says "Hello World." The result is nothing exciting, but it's -important that you understand how to run your app before you start developing.

- - +

How you run your app depends on two things: whether you have a real device running Android and +whether you're using Android Studio. This lesson shows you how to install and run your app on a +real device and on the Android emulator, and in both cases with either Android Studio or the command +line tools.

Run on a Real Device

-

If you have a real Android-powered device, here's how you can install and run your app:

+

If you have a device running Android, here's how to install and run your app.

+ +

Set up your device

  1. Plug in your device to your development machine with a USB cable. -If you're developing on Windows, you might need to install the appropriate USB driver for your -device. For help installing drivers, see the OEM USB -Drivers document.
    2. + If you're developing on Windows, you might need to install the appropriate USB driver for your + device. For help installing drivers, see the OEM + USB Drivers document.
  2. Enable USB debugging on your device.
    • On most devices running Android 3.2 or older, you can find the option under @@ -121,19 +68,20 @@ Drivers document.
-

To run the app from Eclipse:

+

Run the app from Android Studio

  1. Open one of your project's files and click Run +src="{@docRoot}images/tools/as-run.png" style="vertical-align:baseline;margin:0; max-height:1em" /> from the toolbar.
    2. -
  2. In the Run as window that appears, select - Android Application and click OK.
    3. +
  3. In the Choose Device window that appears, select the + Choose a running device radio button, select your device, and click OK + .
-

Eclipse installs the app on your connected device and starts it.

+

Android Studio installs the app on your connected device and starts it.

-

Or to run your app from a command line:

+

Run the app from a command line

  1. Change directories to the root of your Android project and execute: @@ -141,7 +89,7 @@ from the toolbar.
  2. Make sure the Android SDK platform-tools/ directory is included in your PATH environment variable, then execute: 
    adb install bin/MyFirstApp-debug.apk
    3. -
  3. On your device, locate MyFirstActivity and open it.
    4. +
  4. On your device, locate MyFirstApp and open it.

That's how you build and run your Android app on a device! @@ -152,64 +100,67 @@ lesson.

Run on the Emulator

-

Whether you're using Eclipse or the command line, to run your app on the emulator you need to -first create an Android Virtual Device (AVD). An -AVD is a device configuration for the Android emulator that allows you to model different -devices.

+

Whether you're using Android Studio or the command line, to run your app on the emulator you need +to first create an Android Virtual Device (AVD). An +AVD is a device configuration for the Android emulator that allows you to model a specific +device.

- -

Figure 1. The AVD Manager showing a few virtual -devices.

+ +

Figure 1. The AVD Manager showing a virtual device.

-

To create an AVD:

+

Create an AVD

  1. Launch the Android Virtual Device Manager: -
      -
    1. In Eclipse, click Android Virtual Device Manager - from the toolbar.
      2. -
    2. From the command line, change -directories to <sdk>/tools/ and execute: -
      android avd
      3. -
    +
      +
    • In the Android Studio tool bar, click the Android Virtual Device Manager icon + .
      • +
    • From the command line, change directories to <sdk>/tools/ and execute: + 
      android avd
      • +
    2. -
  2. In the Android Virtual Device Manager panel, click New.
    3. -
  3. Fill in the details for the AVD. -Give it a name, a platform target, an SD card size, and a skin (HVGA is default).
    4. -
  4. Click Create AVD.
    5. -
  5. Select the new AVD from the Android Virtual Device Manager and click -Start.
    6. -
  6. After the emulator boots up, unlock the emulator screen.
    7. +
  7. In the Android Virtual Device Manager window, click Create.
    8. +
  8. Enter an AVD Name.
    9. +
  9. Select a Device type. +

    When you select a device type, most of the fields auto-populate.

    +
  10. For Skin select HVGA.
    11. +
  11. For SD Card, enter something small, like 10 MiB. +

    It really doesn't matter what you enter here since you're not using any storage. But if you + reuse this AVD, you might have to adjust this setting.

    12. +
  12. Ignore the Emulation Options and click OK.
    13. +
  13. In the Result screen, click OK.
    14. +
  14. Close the Android Virtual Device Manager window.
-

To run the app from Eclipse:

+

Run the app from Android Studio

    -
  1. Open one of your project's files and click -Run -from the toolbar.
    2. -
  2. In the Run as window that appears, select - Android Application and click OK.
    3. +
  3. In Android Studio, select your project and click Run + + from the toolbar.
    4. +
  4. In the Choose Device window, click the Launch emulator radio + button.
    5. +
  5. From the Android virtual device pull-down menu, select the emulator + you created, and click OK.
-

Eclipse installs the app on your AVD and starts it.

+

It can take a few minutes for the emulator to load itself. You may have to unlock the screen. + When you do, My First App appears on the emulator screen.

-

Or to run your app from the command line:

+

Run your app from the command line

  1. Change directories to the root of your Android project and execute: -
    ant debug
    2. + 
    ant debug
  2. Make sure the Android SDK platform-tools/ directory is included in your -PATH environment -variable, then execute: -
    adb install bin/MyFirstApp-debug.apk
    3. -
  3. On the emulator, locate MyFirstActivity and open it.
    4. + PATH environment variable, then execute: + 
    adb install bin/MyFirstApp-debug.apk
    +
  4. On the emulator, locate MyFirstApp and open it.
-

That's how you build and run your Android app on the emulator! +

That's how you build and run your Android app on the emulator! To start developing, continue to the next lesson.

diff --git a/docs/html/training/basics/firstapp/starting-activity.jd b/docs/html/training/basics/firstapp/starting-activity.jd index f9dcba4..d672838 100644 --- a/docs/html/training/basics/firstapp/starting-activity.jd +++ b/docs/html/training/basics/firstapp/starting-activity.jd @@ -19,7 +19,7 @@ helpoutsWidget=true
  1. Respond to the Send Button
  2. Build an Intent
    3. -
  3. Start the Second Activity
    4. +
  4. Create the Second Activity
  5. Receive the Intent
  6. Display the Message
    7. @@ -40,17 +40,20 @@ SDK

    After completing the previous lesson, you have an app that shows an activity (a single screen) with a text field and a button. In this lesson, you’ll add some -code to MainActivity that +code to MyActivity that starts a new activity when the user clicks the Send button.

    Respond to the Send Button

    -

    To respond to the button's on-click event, open the fragment_main.xml -layout file and add the +

  7. In Android Studio, from the res/layout directory, edit the activity_my.xml +file.
    8. +
  8. To the {@link android.widget.Button <Button>} element, add the {@code android:onClick} -attribute to the {@link android.widget.Button <Button>} element:

    +attribute. +

    res/layout/activity_my.xml

     <Button
     android:layout_width="wrap_content"
@@ -63,10 +66,12 @@ attribute to the {@link android.widget.Button <Button>} element:
    
 href="{@docRoot}reference/android/view/View.html#attr_android:onClick">{@code
 android:onClick} attribute’s value, "sendMessage", is the name of a method in your
 activity that the system calls when the user clicks the button.
    
+
    9. +
  9. In the java/com.mycompany.myfirstapp directory, open the MyActivity.java file.
    10. +
  10. Within the MyActivity class, add the {@code sendMessage()} method stub shown +below. -

    Open the MainActivity class (located in the project's -src/ directory) and add the corresponding method:

    - +

    java/com.mycompany.myfirstapp/MyActivity.java

     /** Called when the user clicks the Send button */
 public void sendMessage(View view) {
@@ -85,32 +90,40 @@ the signature must be exactly as shown. Specifically, the method must:
    
 android.view.View} that was clicked)
    11. + +
+

Next, you’ll fill in this method to read the contents of the text field and deliver that text to another activity.

- -

Build an Intent

-

An {@link android.content.Intent} is an object that provides runtime binding between separate -components (such as two activities). The {@link android.content.Intent} represents an -app’s "intent to do something." You can use intents for a wide -variety of tasks, but most often they’re used to start another activity.

- -

Inside the {@code sendMessage()} method, create an {@link android.content.Intent} to start -an activity called {@code DisplayMessageActivity}:

+
    +
  1. In MyActivity.java, inside the {@code sendMessage()} method, create an +{@link android.content.Intent} to start an activity called {@code DisplayMessageActivity} with the +following code: +

    java/com.mycompany.myfirstapp/MyActivity.java

    -Intent intent = new Intent(this, DisplayMessageActivity.class);
+public void sendMessage(View view) {
+  Intent intent = new Intent(this, DisplayMessageActivity.class);
+}
    -

    This requires that you import the {@link android.content.Intent} class:

    -
    -import android.content.Intent;
-
    +
    +
    +

    Intents

    +

    An {@link android.content.Intent} is an object that provides runtime binding between separate +components (such as two activities). The {@link android.content.Intent} represents an +app’s "intent to do something." You can use intents for a wide +variety of tasks, but most often they’re used to start another activity. For more information, see +Intents and Intent Filters.

    +
    +
    -

    Tip: In Eclipse, press Ctrl + Shift + O to import missing classes -(Cmd + Shift + O on Mac).

    +

    Note: The reference to {@code DisplayMessageActivity} +will raise an error if you’re using an IDE such as Android Studio because the class doesn’t exist yet. +Ignore the error for now; you’ll create the class soon.

    The constructor used here takes two parameters:

      @@ -121,6 +134,19 @@ android.app.Activity} class is a subclass of {@link android.content.Context}) the {@link android.content.Intent} (in this case, the activity that should be started)
    +

    Android Studio indicates that you must import the {@link android.content.Intent} class.

    + +
    2. +
  2. At the top of the file, import the {@link android.content.Intent} class: +

    java/com.mycompany.myfirstapp/MyActivity.java

    +
    +import android.content.Intent;
+
    +

    Tip: In Android Studio, press Alt + Enter (option + return on Mac) + to import missing classes.

    +
    3. + + -

    Note: The reference to {@code DisplayMessageActivity} -will raise an error if you’re using an IDE such as Eclipse because the class doesn’t exist yet. -Ignore the error for now; you’ll create the class soon.

    - -

    An intent not only allows you to start another activity, but it can carry a bundle of data to the -activity as well. Inside the {@code sendMessage()} method, +

  3. Inside the {@code sendMessage()} method, use {@link android.app.Activity#findViewById findViewById()} to get the -{@link android.widget.EditText} element and add its text value to the intent:

    - +{@link android.widget.EditText} element. +

    java/com.mycompany.myfirstapp/MyActivity.java

    -Intent intent = new Intent(this, DisplayMessageActivity.class);
-EditText editText = (EditText) findViewById(R.id.edit_message);
-String message = editText.getText().toString();
-intent.putExtra(EXTRA_MESSAGE, message);
+public void sendMessage(View view) {
+  Intent intent = new Intent(this, DisplayMessageActivity.class);
+  EditText editText = (EditText) findViewById(R.id.edit_message);
+}
    +
    4. -

    Note: -You now need an import statement for android.widget.EditText. -You'll define the EXTRA_MESSAGE constant in a moment.

    +
  4. At the top of the file, import the {@link android.widget.EditText} class. +

    In Android Studio, press Alt + Enter (option + return on Mac) to import missing classes.

    +
    5. -

    An {@link android.content.Intent} can carry a collection of various data types as key-value +

  5. Assign the text to a local message variable, and use the +{@link android.content.Intent#putExtra putExtra()} method to add its text value to the intent. +

    java/com.mycompany.myfirstapp/MyActivity.java

    +
    +public void sendMessage(View view) {
+  Intent intent = new Intent(this, DisplayMessageActivity.class);
+  EditText editText = (EditText) findViewById(R.id.edit_message);
+  String message = editText.getText().toString();
+  intent.putExtra(EXTRA_MESSAGE, message);
+}
+
    + +

    An {@link android.content.Intent} can carry data types as key-value pairs called extras. The {@link android.content.Intent#putExtra putExtra()} method takes the key name in the first parameter and the value in the second parameter.

    -

    In order for the next activity to query the extra data, you should define the key -for your intent's extra using a -public constant. So add the {@code EXTRA_MESSAGE} definition to the top of the {@code -MainActivity} class:

    - +
    6. +
  6. At the top of the {@code MyActivity} class, add the {@code EXTRA_MESSAGE} definition as +follows: +

    java/com.mycompany.myfirstapp/MyActivity.java

    -public class MainActivity extends ActionBarActivity {
-    public final static String EXTRA_MESSAGE = "com.example.myfirstapp.MESSAGE";
+public class MyActivity extends ActionBarActivity {
+    public final static String EXTRA_MESSAGE = "com.mycompany.myfirstapp.MESSAGE";
     ...
 }
    -

    It's generally a good practice to define keys for intent extras using your app's package name -as a prefix. This ensures they are unique, in case your app interacts with other apps.

    +

    For the next activity to query the extra data, you should define the key +for your intent's extra using a public constant. It's generally a good practice to define keys for +intent extras using your app's package name as a prefix. This ensures the keys are unique, in case +your app interacts with other apps.

    +
    7. + +
  7. In the {@code sendMessage()} method, to finish the intent, call the +{@link android.app.Activity#startActivity startActivity()} method, passing it the +{@link android.content.Intent} object created in step 1. -

    Start the Second Activity

    - -

    To start an activity, call {@link android.app.Activity#startActivity -startActivity()} and pass it your {@link android.content.Intent}. The system receives this call -and starts an instance of the {@link android.app.Activity} -specified by the {@link android.content.Intent}.

    +

With this new code, the complete {@code sendMessage()} method that's invoked by the Send button now looks like this:

- +

java/com.mycompany.myfirstapp/MyActivity.java

 /** Called when the user clicks the Send button */
 public void sendMessage(View view) {
@@ -198,70 +234,92 @@ public void sendMessage(View view) {
 }
-

Now you need to create the {@code DisplayMessageActivity} class in order for this to -work.

+

The system receives this call and starts an instance of the {@link android.app.Activity} +specified by the {@link android.content.Intent}. Now you need to create the +{@code DisplayMessageActivity} class in order for this to work.

+ +

Create the Second Activity

+

All subclasses of {@link android.app.Activity} must implement the +{@link android.app.Activity#onCreate onCreate()} method. This method is where the activity receives +the intent with the message, then renders the message. Also, the +{@link android.app.Activity#onCreate onCreate()} method must define the activity +layout with the {@link android.app.Activity#setContentView setContentView()} method. This is where +the activity performs the initial setup of the activity components.

+ +

Create a new activity using Android Studio

+
- -

Figure 1. The new activity wizard in Eclipse.

+ +

Figure 1. The new activity wizard in Android Studio.

-

To create a new activity using Eclipse:

+

Android Studio includes a stub for the +{@link android.app.Activity#onCreate onCreate()} method when you create a new activity.

    -
  1. Click New in the toolbar.
    2. -
  2. In the window that appears, open the Android folder - and select Android Activity. Click Next.
    3. -
  3. Select BlankActivity and click Next.
    4. -
  4. Fill in the activity details: +
  5. In Android Studio, in the java directory, select the package, + com.mycompany.myfirstapp, right-click, and select + New > Activity > Blank Activity.
    6. +
  6. In the Choose options window, fill in the activity details:
      -
    • Project: MyFirstApp
    • Activity Name: DisplayMessageActivity
    • Layout Name: activity_display_message
      • -
    • Fragment Layout Name: fragment_display_message
    • Title: My Message
      • -
    • Hierarchial Parent: com.example.myfirstapp.MainActivity
      • -
    • Navigation Type: None
      • +
    • Hierarchical Parent: com.mycompany.myfirstapp.MyActivity
      • +
    • Package name: com.mycompany.myfirstapp

    Click Finish.

    7. -
- -

If you're using a different IDE or the command line tools, create a new file named -{@code DisplayMessageActivity.java} in the project's src/ directory, next to -the original {@code MainActivity.java} file.

-

Open the {@code DisplayMessageActivity.java} file. If you used Eclipse to create this -activity:

- - -

Fragments decompose application functionality and UI into reusable modules. For more -information on fragments, see the Fragments -API Guide. The final version of this activity does not use fragments.

+
  • Open the {@code DisplayMessageActivity.java} file. + +

    The class already includes an implementation of the required +{@link android.app.Activity#onCreate onCreate()} method. You will update the implementation of this +method later. It also includes an implementation of +{@link android.app.Activity#onOptionsItemSelected onOptionsItemSelected()}, which handles the action +bar's Up behavior. Keep these two methods as they are for now.

    + + +
    • + +
  • Remove the {@link android.app.Activity#onCreateOptionsMenu onCreateOptionsMenu()} method. +

    You won't need it for this app.

    +
    • + + + +

    If you're developing with Android Studio, you can run the app now, but not much happens. +Clicking the Send button starts the second activity, but it uses +a default "Hello world" layout provided by the template. You'll soon update the +activity to instead display a custom text view.

    + + +

    Create the activity without Android Studio

    -

    The {@code DisplayMessageActivity} class should now look like this:

    +

    If you're using a different IDE or the command line tools, do the following:

    + +
      +
    1. Create a new file named {@code DisplayMessageActivity.java} in the project's src/ +directory, next to the original {@code MyActivity.java} file.
      2. +
    2. Add the following code to the file: 
       public class DisplayMessageActivity extends ActionBarActivity {
@@ -307,63 +365,44 @@ public class DisplayMessageActivity extends ActionBarActivity {
 }
      -

      If you used an IDE other than Eclipse, update your {@code DisplayMessageActivity} -class with the above code.

      - -

      All subclasses of {@link android.app.Activity} must implement the {@link -android.app.Activity#onCreate onCreate()} method. The system calls this when creating a new -instance of the activity. This method is where you must define the activity layout -with the {@link android.app.Activity#setContentView setContentView()} method -and is where you should -perform initial setup for the activity components.

      - -

      Note: If you are using an IDE other than Eclipse, your project +

      Note: If you are using an IDE other than Android Studio, your project does not contain the {@code activity_display_message} layout that's requested by {@link android.app.Activity#setContentView setContentView()}. That's OK because you will update this method later and won't be using that layout.

      +
      3. -

      Add the title string

      - -

      If you used Eclipse, you can skip to the next section, -because the template provides -the title string for the new activity.

      - -

      If you're using an IDE other than Eclipse, -add the new activity's title to the {@code strings.xml} file:

      +
    3. To your {@code strings.xml} file, add the new activity's title as follows: 
       <resources>
     ...
     <string name="title_activity_display_message">My Message</string>
 </resources>
      +
      4. - - -

      Add it to the manifest

      - -

      All activities must be declared in your manifest file, AndroidManifest.xml, using an -{@code <activity>} element.

      - -

      When you use the Eclipse tools to create the activity, it creates a default entry. If you're -using a different IDE, you need to add the manifest entry yourself. It should -look like this:

      +
    4. In your manifest file, AndroidManifest.xml, within the Application +element, add the +{@code <activity>} element +for your {@code DisplayMessageActivity} class, as follows: 
       <application ... >
     ...
     <activity
-        android:name="com.example.myfirstapp.DisplayMessageActivity"
+        android:name="com.mycompany.myfirstapp.DisplayMessageActivity"
         android:label="@string/title_activity_display_message"
-        android:parentActivityName="com.example.myfirstapp.MainActivity" >
+        android:parentActivityName="com.mycompany.myfirstapp.MyActivity" >
         <meta-data
             android:name="android.support.PARENT_ACTIVITY"
-            android:value="com.example.myfirstapp.MainActivity" />
+            android:value="com.mycompany.myfirstapp.MyActivity" />
     </activity>
 </application>
      +
      5. +
    +

    The {@code android:parentActivityName} attribute declares the name of this activity's parent activity within the app's logical hierarchy. The system uses this value @@ -376,20 +415,16 @@ the {@code <meta-data>} element as shown here.

    Note: Your Android SDK should already include -the latest Android Support Library. It's included with the ADT Bundle but if you're using -a different IDE, you should have installed it during the -Adding Platforms and Packages step. -When using the templates in Eclipse, the Support Library is automatically added to your app project +the latest Android Support Library, which you installed during the +Adding SDK Packages step. +When using the templates in Android Studio, the Support Library is automatically added to your app project (you can see the library's JAR file listed under Android Dependencies). If you're not using -Eclipse, you need to manually add the library to your project—follow the guide for setting up the Support Library then return here.

    -

    If you're developing with Eclipse, you can run the app now, but not much happens. -Clicking the Send button starts the second activity but it uses -a default "Hello world" layout provided by the template. You'll soon update the -activity to instead display a custom text view, so if you're using a different IDE, -don't worry that the app won't yet compile.

    +

    If you're using a different IDE than Android Studio, don't worry that the app won't yet compile. +You'll soon update the activity to display a custom text view.

    Receive the Intent

    @@ -397,24 +432,55 @@ don't worry that the app won't yet compile.

    Every {@link android.app.Activity} is invoked by an {@link android.content.Intent}, regardless of how the user navigated there. You can get the {@link android.content.Intent} that started your activity by calling {@link android.app.Activity#getIntent()} and retrieve the data contained -within it.

    - -

    In the {@code DisplayMessageActivity} class’s {@link android.app.Activity#onCreate onCreate()} -method, get the intent and extract the message delivered by {@code MainActivity}:

    +within the intent.

    +
      +
    1. In the java/com.mycompany.myfirstapp directory, edit the + {@code DisplayMessageActivity.java} file.
      2. +
    2. In the {@link android.app.Activity#onCreate onCreate()} method, remove the following line: +
      +  setContentView(R.layout.activity_display_message);
+
      +
    3. Get the intent and assign it to a local variable. 
       Intent intent = getIntent();
-String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
      - - +
      4. +
    4. At the top of the file, import the {@link android.content.Intent} class. +

      In Android Studio, press Alt + Enter (option + return on Mac) to import missing classes.

      +
      5. +
    5. Extract the message delivered by {@code MyActivity} with the +{@link android.content.Intent#getStringExtra getStringExtra()} method. +
      +String message = intent.getStringExtra(MyActivity.EXTRA_MESSAGE);
+
      +
      6. +

    Display the Message

    -

    To show the message on the screen, create a {@link android.widget.TextView} widget and set the -text using {@link android.widget.TextView#setText setText()}. Then add the {@link -android.widget.TextView} as the root view of the activity’s layout by passing it to {@link -android.app.Activity#setContentView setContentView()}.

    +
      +
    1. In the {@link android.app.Activity#onCreate onCreate()} method, create a {@link android.widget.TextView} object. +
      +TextView textView = new TextView(this);
+
      +
      2. +
    2. Set the text size and message with {@link android.widget.TextView#setText setText()}. +
      +textView.setTextSize(40);
+textView.setText(message);
+
      +
      3. +
    3. Then add the {@link android.widget.TextView} as the root view of the activity’s layout by +passing it to {@link android.app.Activity#setContentView setContentView()}. +
      +setContentView(textView);
+
      +
      4. +
    4. At the top of the file, import the {@link android.widget.TextView} class. +

      In Android Studio, press Alt + Enter (option + return on Mac) to import missing classes.

      +
      5. +

    The complete {@link android.app.Activity#onCreate onCreate()} method for {@code DisplayMessageActivity} now looks like this:

    @@ -426,7 +492,7 @@ public void onCreate(Bundle savedInstanceState) { // Get the message from the intent Intent intent = getIntent(); - String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE); + String message = intent.getStringExtra(MyActivity.EXTRA_MESSAGE); // Create the text view TextView textView = new TextView(this); -- cgit v1.1