3. Tip Calculator App

You’ll begin by test-driving the app. Then we’ll overview the technologies you’ll use to create the app. You’ll build the app’s GUI using Android Studio’s layout editor and the Component Tree window. Finally, we’ll present the complete Java code for the app and do a detailed code walkthrough.

1. Touch the home () icon on your AVD or device.

2. On the home screen, touch the launcher () icon, then open the Settings app.

3. In the Personal section, touch Language and Input.

4. On an AVD, touch Android Keyboard (AOSP). On a device touch Google Keyboard—we assume you’re using the standard Android keyboard.

5. Touch Appearance & layouts, then touch Theme.

6. Touch Material Dark to change to the keyboard with the dark background.

• converts it to a number

• divides the number by 100.0 and displays the new bill amount

• recalculates the tip and total amounts, based on the current tip percentage (15% by default) and

• displays in the Tip and Total TextViews the new tip and total amounts.

If you delete all the digits, the app redisplays Enter Amount in the blue TextView and displays 0.00 in the orange TextViews. The app divides the value by 100.0 and displays the result in the blue TextView. The app then calculates and updates the tip and total amounts in the orange TextViews.

All monetary amounts are displayed in locale-specific currency formats and the tip percentage is displayed in a locale-specific percentage format. For the U.S. locale, as you enter the four digits 5, 6, 3 and 2, the bill total is displayed successively as $0.05, $0.56, $5.63 and $56.32, respectively.

• use various Android classes to create objects

• call methods on classes and objects

• define and call your own methods

• use inheritance to create a class that defines the Tip Calculator’s functionality and

• use event handling, anonymous inner classes and interfaces to process the user’s GUI interactions.

Before Android 3.0, a separate Activity was typically associated with each screen of an app. As you’ll see, starting in Chapter 4, an Activity can manage multiple Fragments. On a phone, each Fragment typically occupies the entire screen and the Activity switches between the Fragments, based on user interactions. On a tablet, activities typically display multiple Fragments per screen to take advantage of the larger screen size.

• An active Activity is visible on the screen and “has the focus”—that is, it’s in the foreground. You can interact with the Activity currently in the foreground.

• A paused Activity is visible on the screen but does not have the focus—such as when an alert dialog is displayed. You cannot interact with the paused activity until it becomes active—for example, after the user dismisses an alert dialog.

• A stopped activity is not visible on the screen—it’s in the background and is likely to be killed by the system when its memory is needed. An Activity is stopped when another Activity enters the foreground and becomes active. For example, when you answer a phone call, the phone app becomes active and the app you previously were using is stopped.

As an Activity transitions among these states, the Android runtime calls various Activity lifecycle methods—all of which are defined by the Activity class in package android.app. You’ll override the onCreate method in every activity. This method is called by the Android runtime when an Activity is starting—that is, when its GUI is about to be displayed so you can interact with the Activity. Other lifecycle methods include onStart, onPause, onRestart, onResume, onStop and onDestroy. We’ll discuss most of these in later chapters. Each activity lifecycle method you override must call the superclass’s version; otherwise, an exception will occur. This is required because each lifecycle method in superclass Activity contains code that must execute in addition to the code you define in your overridden lifecycle methods. For more on the Activity lifecycle see

One such library is the AppCompat library, which enables apps to provide an app bar (formerly called an action bar) and more on devices running Android 2.1 (API 7) and higher—app bars were originally introduced in Android 3.0 (API 11). Android Studio’s app templates have been updated to use the AppCompat library, enabling the new apps you create to run on almost all Android devices.

Android Studio’s Empty Activity app template defines the app’s MainActivity class as a subclass of AppCompatActivity (package android.support.v7.app)—an indirect subclass of Activity that supports using newer Android features in apps running on current and older Android platforms.

For more details on Android Support Libraries, including when to use them and how to set them up, visit:

We’ll cover more layouts and views in later chapters—for a complete list, visit

An EditText—often called a text box or text field in other GUI technologies—is a subclass of TextView (presented in Chapter 2) that can display text and accept text input from the user. You’ll specify an EditText for numeric input, allow users to enter only digits and restrict the maximum number of digits that can be entered.

A SeekBar represents an integer in the range 0–100 by default and allows the user to select a number in that range by moving the SeekBar’s thumb. You’ll customize the SeekBar so the user can choose a tip percentage from the more limited range 0 to 30.

• The “light” theme has a white app bar, a white app background and text that is black or shades of dark gray.

• The “light” theme with a dark app bar is the same as above, but the app bar is black with white text by default.

• The “dark” has a black app bar, a dark gray app background and text that is white or shades of light gray.

For each of these themes, there is

• a Theme.Material version (e.g., Theme.Material.Light) for apps that do not use any AppCompat libraries and run on Android 5 and higher, and

• a Theme.AppCompat version (e.g., Theme.AppCompat.Light) for apps that use AppCompat libraries and run on Android 2.1 and higher.

When designing a GUI, you can choose from the predefined themes, or even create your own new ones. For this chapter, we’ll use Theme.AppCompat.Light.DarkActionBar, which is the default theme in Android Studio’s app templates. Apps that use the AppCompat libraries must use one of the AppCompat themes; otherwise, some views will not render correctly. For more information about each theme and to see sample screen captures, visit

The material design guidelines contain elevation recommendations for various onscreen components—for example, a dialog’s recommended elevation is 24dp and a menu’s is 8dp. For other recommended elevations, see:

1. http://www.google.com/design/spec/style/color.html.

You can find recommended sample color swatches from the material design color palette at

For palette color recommendations, visit

This site enables you to click two colors from Google’s material design color palette, then it recommends three shades of the primary color, one secondary color and colors for your app’s text and icons.

In this app, we’ll use color swatches displayed in the Android Studio Theme Editor to select

• a blue primary color for app bar’s background color

• a darker blue dark primary color for the status bar that appears above the app bar, and

• an orange accent color used to tint the SeekBar.

For the amount TextView’s light blue color and the tip and total TextViews’ light orange color, we used Google’s material design color palette to choose lighter shades of the primary and accent colors.

The window will also scroll to the specific property that best matches what you type. For example, when searching a TextView’s properties, if you type "text co" or "textco", the Properties window will highlight portions of many properties, but it specifically scrolls to and highlights the textColor property.

When you drag a view onto a GridLayout in the Component Tree, the view occupies the next available grid cell—cells populate the GridLayout left-to-right until a given row is full, then the next view appears in the first column of the next row. As you’ll see, you also can specify the exact row and column in which to place a view. We’ll discuss other GridLayout features as we present the GUI-building steps.

• Application name: Tip Calculator

• Company Domain: deitel.com (or specify your own domain name)

For the remaining steps in the Create New Project dialog, use the same settings as in Section 2.3. Also, follow the steps in Section 2.5.2 to add an app icon to your project.

Once the project is open in Android Studio, in the layout editor, select Nexus 6 from the virtual-device drop-down list (Fig. 2.11). Once again, we’ll use this device as the basis for our design. Also, delete the Hello world! TextView.

1. Click the Text tab at the bottom of the layout editor to switch from the Design view to the layout’s XML text.

2. At the top of the XML, change RelativeLayout to GridLayout.

3. Switch back to the layout editor’s Design tab.

By default, there are no margins—spacing that separates views—around a GridLayout’s cells. The material design guidelines recommend 8dp minimum spacing between views:

GridLayout can enforce this recommended spacing. With the GridLayout selected in the Component Tree, in the Properties window, check the GridLayout’s useDefaultMargins property (which sets it to true) to use the recommended margins around the layout’s cells.

You may also drag views directly onto the layout editor. For a GridLayout, the layout editor displays a grid of green guidelines to help you position the view. As you drag a view over the grid, the layout editor displays a tooltip indicating the row and column in which the view will be placed if you drop the view at that location.

This app’s TextViews use the medium-sized font from the app’s theme. The layout editor’s Palette provides preconfigured TextViews named Plain Text, Large Text, Medium Text and Small Text (in the Widgets section) for various text sizes. The Plain Text TextView uses the theme’s default font size. For the others, the IDE configures the TextView’s textAppearance property using the Material theme’s styles for the corresponding font sizes.

Perform the following steps to add to the GridLayout an EditText and a TextView for receiving and displaying the bill amount:

1. This app allows you to enter only nonnegative integers, which the app divides by 100.0 to display the bill amount. The Palette’s Text Fields section provides preconfigured EditTexts for various forms of input, including person names, passwords, e-mail addresses, phone numbers, times, dates and numbers. When the user interacts with an EditText, an appropriate keyboard is displayed, based on the EditText’s input type. From the Palette’s Text Fields section, drag and drop a Number EditText onto the GridLayout node in the Component Tree window—this creates an EditText with the id editText in the GridLayout. Change the id to amountEditText. The EditText is placed in the first column of the GridLayout’s first row. Set the EditText’s layout:column to 0 and the layout:columnSpan to 2—these settings ensure that the TextView spans both columns of row 0.

2. Drag a Medium Text TextView from the Palette’s Widgets section over the amountEditText in the Component Tree window—a horizontal black line appears below amountEditText, indicating that the TextView will be placed after amountEditText. The IDE creates a new TextView named textView and nests it in the GridLayout node. The default text "Medium Text" appears in the layout editor. You’ll change this in Step 5 (Section 3.4.5). Change the TextView’s id to amountTextView, then set the layout:row to 0, the layout:column to 0 and the layout:columnSpan to 2—these settings ensure that the TextView spans both columns of row 0, as you’ll see once we change the TextView’s background color.

1. Drag a Medium TextView (percentTextView) from the Palette’s Widgets section over the amountTextView in the GridLayout node in the Component Tree window. The new view becomes the first view in row 1 (the second row).

2. Drag a SeekBar (percentSeekBar) from the Palette’s Widgets section over the percentTextView in the GridLayout node in the Component Tree window. The new view becomes the second view in row 1.

1. Drag a Medium TextView (tipLabelTextView) over the percentSeekBar in the GridLayout node. The new view becomes the first view in row 2 (the third row).

2. Drag a Medium TextView (tipTextView) over the tipLabelTextView in the GridLayout node. The new view becomes the second view in row 2.

1. Drag a Medium TextView (totalLabelTextView) over the tipTextView in the GridLayout node. This becomes the first view in row 3 (the fourth row).

2. Drag a Medium TextView (totalTextView) over the totalLabelTextView in the GridLayout node. This becomes the second view in row 3.

Normally, you’d touch the EditText to redisplay the virtual keyboard. In this app, however, the EditText is hidden behind a TextView. If you were to dismiss this app’s keyboard, you’d have to leave the app and return to it to redisplay the keyboard. We could programmatically force the keyboard to stay on the screen, but this would prevent the back button from ever being displayed in this app. This, in turn, would prevent you from returning to the previous Activity—a basic Android feature that every user expects.

We used an Android virtual keyboard to demonstrate how to choose the keyboard displayed for a given EditText. Another approach would be to provide Buttons representing the digits 0–9 that always remain on the screen. We could handle their click events and use String manipulation rather than an EditText to keep track of the user input.

1. In the Component Tree, select amountTextView and locate its hint property in the Properties window.

2. Click the ellipsis (...) button to the right of the property’s value to display the Resources dialog.

3. In the dialog, click New Resource, then select New String Value... to display the New String Value Resource dialog and set the Resource name to enter_amount and Resource value to "Enter Amount". Leave the other settings and click OK to create the new String resource and set it as amountTextView’s hint.

Repeat these steps to set the text property for the percentTextView, tipLabelTextView and totalLabelTextView using the values shown in Fig. 3.5.

1. Select the percentTextView.

2. Hold Ctrl on Windows/Linux or Command on Mac and click the tipLabelTextView and totalLabelTextView. Now all three TextViews are selected.

3. Expand the layout:gravity property’s node and check the right checkbox.

1. Set the digits property to 0123456789—this allows only digits to be entered, even though the numeric keypad contains other characters, such as minus (-), comma (,) and period (.).

2. Set the maxLength property to 6. This restricts the bill amount to a maximum of six digits—so the largest supported bill amount is 9999.99.

1. Delete the default value of the text property ("Medium Text")—we’ll programmatically display text here, based on the user’s input.

2. Expand the layout:gravity property’s node and set the fill to horizontal. This indicates that the TextView should occupy all remaining horizontal space in this GridLayout row.

3. Set the background property (which specifies the view’s background color) to a new color resource named amount_background with the value #BBDEFB—a light blue color chosen from Google’s material design color palette.

4. Add padding around the TextView. A view’s padding specifies extra space around a view’s content. The all property specifies that the padding amount should be applied to the top, right, bottom and left of the view’s contents. You may also set the padding for each of these individually. Expand the padding property’s node, click the all property, then click the ellipsis button. Create a new dimension resource named textview_padding with the value 12dp. You’ll use this resource again shortly.

5. Finally, add a shadow to the view by setting the elevation property to a new dimension resource named elevation with the value 4dp. We chose this value for demonstration purposes to emphasize the shadow effect.

Click here to view code image

A vertical bar (|) is used to separate multiple layout:gravity values—in this case indicating that the TextView should be centered vertically and right aligned within the grid cell.

1. By default, a SeekBar’s range is 0 to 100 and its current value is indicated by its progress property. This app allows tip percentages from 0 to 30 and specifies a default of 15 percent. Set the SeekBar’s max property to 30 and the progress property to 15.

2. Expand the layout:gravity property’s node and set the fill to horizontal so the SeekBar occupies all horizontal space in the SeekBar’s GridLayout column.

3. Set the layout:height property to a new dimension resource (seekbar_height) with the value 40dp to increase vertical space in which the SeekBar is displayed.

1. Delete the default value of the text property ("Medium Text")—we’ll programmatically display the calculated tip and total.

2. Expand the layout:gravity property’s node and set the fill to horizontal so each TextView occupies all horizontal space in the TextViews’ GridLayout column.

3. Set the background property to a new color resource named result_background with the value #FFE0B2—a light orange color chosen from Google’s material design color palette.

4. Set the gravity property to center so the calculated tip and total amounts will be centered within these TextViews.

5. Expand the padding property’s node, click the ellipsis button for the all value, then select the dimension resource named textview_padding that you created previously for the amountTextView.

6. Finally, add a shadow to each view by setting the elevation property to the elevation dimension resource you created earlier.

As we mentioned previously, Android Studio’s app templates now include support for the AppCompat libraries that enable you to use newer Android features in older Android versions. By default, Android Studio sets the parent theme to

Click here to view code image

one of several predefined themes from the AppCompat library—apps that use this theme have a light background, except for the dark app bar at the top of the app. Each AppCompat theme uses Google’s material design recommendations to style your apps’ GUIs.

1. Open styles.xml. In the editor’s upper-right corner, click the Open editor link to display the Theme Editor (Fig. 3.7) showing the current colors for colorPrimary (dark blue), colorPrimaryDark (a darker shade of colorPrimary) and colorAccent (bright pink)—these are the default colors specified in Android Studio’s Empty Activity app template. For this app, we’ll change colorPrimary and colorPrimaryDark to lighter blues and change colorAccent to orange.

2. Customize the app’s colorPrimary value by clicking its color swatch (Fig. 3.7) to display the Resources dialog (Fig. 3.8). In the dialog, click the Material Blue 500 color swatch, then click OK to change colorPrimary’s value—hovering the mouse cursor over a color swatch displays its color name in a tooltip. The number 500 represents a particular shade of the Material Blue color. Shades of each color range from 50 (a light shade) to 900 (a dark shade)—you can view samples of each color’s shades at

3. Next, click the colorPrimaryDark color swatch in the Theme Editor to display the Resources dialog. The Theme Editor recognizes the new colorPrimary value and automatically displays a color swatch containing the recommended darker colorPrimary shade you should use for colorPrimaryDark—in this case, Material Blue 700. Click that color swatch (Fig. 3.9), then click OK.

4. Next, click the colorAccent color swatch in the Theme Editor to display the Resources dialog. Again, the Theme Editor recognizes that you changed the colorPrimary value and displays swatches for various complementary accent colors. In the dialog, click the Orange accent 400 color swatch, then click OK to change colorAccent’s value (Fig. 3.10), then click OK.

You’ve now completed the app’s design, which should appear as shown in Fig. 3.11.

Click here to view code image

Fig. 3.12 | MainActivity’s package and import statements.

Lines 5–14 import the classes and interfaces the app uses:

• Class Bundle of package android.os (line 5) stores key–value pairs of information—typically representing an app’s state or data that needs to be passed between activities. When another app is about to appear on the screen—e.g., when the user receives a phone call or launches another app—Android gives the currently executing app the opportunity to save its state in a Bundle. The Android runtime might subsequently kill the app—e.g., to reclaim its memory. When the app returns to the screen, the Android runtime passes the Bundle of the previously saved state to Activity method onCreate (Section 3.6.4). Then, the app can use the saved state to return the app to the state it was in when another app became active. We’ll use Bundles in Chapter 8 to pass data between activities.

• Class AppCompatActivity of package android.support.v7.app (line 6) provides the basic lifecycle methods of an app—we’ll discuss these shortly. AppCompatActivity is an indirect subclass of Activity (package android.app) that supports using newer Android features apps running on current and older Android platforms.

• Interface Editable of package android.text (line 7) allows you to modify the content and markup of text in a GUI.

• You implement interface TextWatcher of package android.text (line 8) to respond to events when the user changes the text in an EditText.

• Package android.widget (lines 9, 10 and 12) contains the widgets (i.e., views) and layouts that are used in Android GUIs. This app uses EditText (line 9), SeekBar (line 10) and TextView (line 12) widgets.

• You implement interface SeekBar.OnSeekBarChangeListener of package android.widget (line 11) to respond to the user moving the SeekBar’s thumb.

• Class NumberFormat of package java.text (line 14) provides numeric formatting capabilities, such as locale-specific currency and percentage formats.

Click here to view code image

Fig. 3.13 | Class MainActivity is a subclass of Activity.

Click here to view code image

Fig. 3.14 | MainActivity class’s instance variables.

The bill amount entered by the user into amountEditText will be read and stored as a double in billAmount (line 25). The tip percentage (an integer in the range 0–30) that the user sets by moving the Seekbar thumb will be divided by 100.0 to create a double for use in calculations, then stored in percent (line 26). For example, if you select 25 with the SeekBar, percent will store 0.25, so the app will multiply the bill amount by 0.25 to calculate the 25% tip.

Line 27 declares the TextView that displays the currency-formatted bill amount. Line 28 declares the TextView that displays the tip percentage, based on the SeekBar thumb’s position (see the 15% in Fig. 3.1(a)). The variables in lines 29–30 will refer to the TextViews in which the app displays the calculated tip and total.

Click here to view code image

Fig. 3.15 | Overriding Activity method onCreate.

• class R.drawable—contains constants for any drawable items, such as images, that you put in the various drawable folders in your app’s res folder

• class R.id—contains constants for the views in your XML layout files

• class R.layout—contains constants that represent each layout file in your project (such as, activity_main.xml), and

• class R.string—contains constants for each String in the strings.xml file.

Lines 39–42 obtain references to the TextViews that we change programmatically in the app. Line 39 obtains a reference to the amountTextView that’s updated when the user enters the bill amount. Line 40 obtains a reference to the percentTextView that’s updated when the user changes the tip percentage. Lines 41–42 obtain references to the TextViews where the calculated tip and total are displayed.

Lines 52–53 get a reference to the percentSeekBar. Line 54 calls the SeekBar’s setOnSeekBarChangeListener method to register the OnSeekBarChangeListener object that responds to events generated when the user moves the SeekBar’s thumb. Figure 3.17 defines this listener as an anonymous-inner-class object that’s assigned to the instance variable seekBarListener.

In addition, each layout XML file that contains views with ids has a corresponding autogenerated class. For each view with an id, the class has a public final instance variable referencing that view. You can create an instance of this “Binding” class to replace all calls to findViewById, which can greatly simplify your onCreate methods in Activity and Fragment classes with complex user interfaces. Each instance variable’s name is the id specified in the layout for the corresponding view. The “Binding” class’s name is based on the layout’s name—for activity_main.xml, the class name is ActivityMainBinding.

At the time of this writing, the Data Binding library is an early beta release that’s subject to substantial changes, both in the syntax of data-binding expressions and in the Android Studio tool support. You can learn more about Android data binding at

Click here to view code image

Fig. 3.16 | MainActivity Method calculate.

Click here to view code image

Fig. 3.17 | Anonymous inner class that implements interface OnSeekBarChangeListener.

Click here to view code image

Fig. 3.18 | Anonymous inner class that implements interface TextWatcher.

Line 97 converts the user input from amountEditText to a double. We allow users to enter only whole numbers in pennies, so we divide the converted value by 100.0 to get the actual bill amount—e.g., if the user enters 2495, the bill amount is 24.95. Line 98 displays the updated bill amount. If an exception occurs, lines 101–102 clear the amountTextView and set the billAmount to 0.0. Lines 105 calls calculate to recalculate and display the tip and total, based on the current bill amount.

Click here to view code image

Fig. 3.19 | AndroidManifest.xml contents.

• android:allowBackup—Whether or not the app’s data should be backed up automatically by Android so that the data can be restored to the device or a new device at a later time.

• android:icon—The app icon that you touch in the launcher to execute the app.

• android:label—The app’s name that’s typically displayed below the icon in the launcher and often displayed in the app bar when the app is executing.

• android:supportsRtl—Whether or not the app’s interface can be flipped horizontally to support right-to-left languages like Arabic and Hebrew.

• android:theme—The theme that determines the default look-and-feel of the app’s views.

The application element’s nested elements define app components, such as activities.

• android:name—The Activity’s class name. The notation ".MainActivity" is shorthand for "com.deitel.MainActivity" (where com.deitel is the reverse of the domain name you specified when creating the app’s project).

• android:label—The Activity’s name. This is often displayed in the app bar when the Activity is on the screen. For single Activity apps, this name is typically the same as the app’s name.

For MainActivity, we added the following attributes:

• android:screenOrientation—In general, most apps should support both portrait and landscape orientations. In portrait orientation, the device’s longer dimension is vertical. In landscape orientation, the device’s longer dimension is horizontal. In the Tip Calculator app, rotating the device to landscape orientation on a typical phone would cause the numeric keypad to obscure most of the Tip Calculator’s GUI. For this reason, we set this property to "portrait" to support only portrait orientation.

• android:windowSoftInputMode—In the Tip Calculator app, the soft keypad should be displayed immediately when the app executes and should reappear each time the user returns to the Tip Calculator app. For this reason we set this property to "stateAlwaysVisible". This will not display the soft keyboard if a hard keyboard is present.

• Most social-networking Android apps provide their own photo-sharing capabilities. Each app can advertise in its manifest its specific Activity that uploads a photo to the user’s account.

• Other apps can use these photo-sharing capabilities, rather than implementing their own. For example, a photo-editing app can provide a Share Photo option. The app can respond to a user’s photo-sharing request by stating its intent to share a photo—that is, creating a photo-sharing Intent and passing it to Android.

• Android looks at the Intent to determine which installed applications provide activities that can share photos.

• If there’s only one such app, Android executes that app’s photo-sharing Activity.

• If there are many such apps, Android displays a list of apps and asks the user to decide which app’s photo-sharing Activity should execute.

A key benefit of this loosely coupled approach is that the photo-editing app’s developer does not need to incorporate support for every possible social-networking site. By issuing a photo-sharing Intent, the app automatically supports any app that declares a photo-sharing Activity in its manifest, including those apps the user has already installed and any the user chooses to install in the future. For a list of the items that can be used with Intents, visit

Android also passes the Intent to the Activity, because an Intent often contains data the Activity can use to perform its task. For example, a photo-editing app can include in a share-photo Intent the specific photo to share.

The intent-filter element must contain one or more action elements. The action "android.intent.action.MAIN" in line 17 of Fig. 3.19 indicates that MainActivity is the Activity to execute when the app launches. The optional category element in line 19 specifies what initiates the Intent—for "android.intent.category.LAUNCHER", it’s the device’s launcher. This category also indicates that the Activity should appear as an icon in the device’s launcher with the icons for the user’s other installed apps.

We’ll discuss and program with Intents in the next chapter. For more information on Intents and Intent filters, visit

In the app’s GUI, you used a GridLayout to arrange the views into rows and columns. You displayed text in TextViews and received input from an EditText and a SeekBar.

The MainActivity class required many Java object-oriented programming capabilities, including classes, objects, methods, interfaces, anonymous inner classes and inheritance. We explained the notion of inflating the GUI from its XML file into its screen representation. You learned about Android’s Activity class and part of the Activity lifecycle. In particular, you overrode the onCreate method to initialize the app when it’s launched. In the onCreate method, you used Activity method findViewById to get references to each of the views the app interacts with programmatically. You defined an anonymous inner class that implements the TextWatcher interface so the app can calculate new tips and totals as the user enters the bill amount in the EditText. You also defined an anonymous inner class that implements the OnSeekBarChangeListener interface so the app can calculate a new tip and total as the user changes the tip percentage by moving the SeekBar’s thumb.

Finally, you edited the AndroidManifest.xml file to specify that the MainActivity supports only portrait orientation and that the MainActivity should always display the keypad. We also discussed the other elements that Android Studio placed in the manifest when you created the project.

In Chapter 4, you’ll build the Flag Quiz app in which the user is shown a graphic of a country’s flag and must guess the country from 2, 4, 6 or 8 choices. You’ll use a menu and checkboxes to customize the quiz, specifying the number of guess options and limiting the flags to specific regions of the world.

a) A(n) __________—often called a text box or text field in other GUI technologies—is a subclass of TextView that can display text and accept text input from the user.

b) Use a(n) __________ to arrange GUI components into cells in a rectangular grid.

c) Android Studio’s __________ window shows the nested structure of the GUI.

d) Class __________ of package android.os represents an app’s state information.

e) You implement interface __________ of package android.text to respond to events when the user interacts with an EditText component.

f) Before Android 3.0, a separate __________ was typically associated with each screen of an app.

g) The method __________ is called by the system when an Activity is starting—that is, when its GUI is about to be displayed so that the user can interact with the Activity.

h) As you build your app’s GUI and add resources (such as strings in the strings.xml file or GUI components in a layout XML file) to your app, the IDE generates a class named __________ that contains nested static classes representing each type of resource in your project’s res folder.

i) Class __________ (nested in class R) contains constants for any drawable items, such as images, that you put in drawable folder in your app’s res folder.

j) Class __________ (nested in class R) contains constants for each String in the strings.xml file.

k) Once the layout is inflated, you can get references to the individual widgets using Activity’s __________ method. This method takes an int constant for a specific view (that is, a GUI component) and returns a reference to it.

3.2 State whether each of the following is true or false. If false, explain why.

a) Method onCreate typically initializes the Activity’s instance variables and GUI components. This method should be as simple as possible so that the app loads quickly. In fact, if the app takes longer than five seconds to load, the operating system will display an ANR (Application Not Responding) dialog—giving the user the option to forcibly terminate the app.

b) As with all Java programs, Android apps have a main method.

c) An active (or running) activity is visible on the screen and “has the focus”—that is, it’s in the background.

d) A stopped activity is visible on the screen and is likely to be killed by the system when its memory is needed.

a) EditText.

b) GridLayout.

c) Outline.

d) Bundle.

e) TextWatcher.

f) activity.

g) onCreate.

h) R.

i) R.drawable.

j) R.string.

k) findViewById.

3.2

a) True.

b) False. Android apps don’t have a main method.

c) False. An active (or running) activity is visible on the screen and “has the focus”—that is, it’s in the foreground.

d) False. A stopped activity is not visible on the screen and is likely to be killed by the system when its memory is needed.

a) String literals should be placed in the strings.xml file in the app’s __________ folder.

b) Class __________ of package android.app provides the basic lifecycle methods of an app.

c) Interface __________ of package android.text allows you to change the content and markup of text in a GUI.

d) You implement interface __________ of package android.widget to respond to the user moving the SeekBar’s thumb.

e) Android apps have four types of components—activities, services, content providers and __________.

f) Throughout its life an activity can be in one of several states—active (or running), paused or __________. The activity transitions between these states in response to various events.

g) Class __________ (nested in class R) contains constants for the GUI components in your XML layout files.

h) Method setContentView uses a received constant to load the corresponding XML document, which is then parsed and converted into the app’s GUI. This process is known as __________ the GUI.

i) You can use Android Studio’s __________ to modify a theme’s colors.

3.4 State whether each of the following is true or false. If false, explain why.

a) By default, a Seekbar allows you to select values from 0 to 255.

b) A GUI component can span multiple columns in a GridLayout.

c) Every Activity subclass must override the construct method.

d) A paused activity is visible on the screen and has the focus.

e) Time-consuming initializations should be done in an onCreate method instead of the background process.

f) You override the onStart method to initialize the app when it’s launched.

g) AppCompat is an indirect subclass of Activity that supports using newer Android features in apps running on current and older Android platforms.

h) Apps that use the AppCompat libraries must use one of the AppCompat themes; otherwise, some views will not render correctly.

3.5 (Enhanced Tip Calculator App) Make the following enhancements to the Tip Calculator app:

a) Add an option to calculate the tip based on either the price before tax or after tax.

b) Allow the user to enter the number of people in the party. Calculate and display the amount owed by each person if the bill were to be split evenly among the party members.

3.6 (Mortgage Calculator App) Create a mortgage calculator app that allows the user to enter a purchase price, down payment amount and an interest rate. Based on these values, the app should calculate the loan amount (purchase price minus down payment) and display the monthly payment for 10, 20 and 30 year loans. Allow the user to select a custom loan duration (in years) by using a SeekBar and display the monthly payment for that custom loan duration.

3.7 (College Loan Payoff Calculator App) A bank offers college loans that can be repaid in 5, 10, 15, 20, 25 or 30 years. Write an app that allows the user to enter the amount of the loan and the annual interest rate. Based on these values, the app should display the loan lengths in years and their corresponding monthly payments.

3.8 (Car Payment Calculator App) Typically, banks offer car loans for periods ranging from two to five years (24 to 60 months). Borrowers repay the loans in monthly installments. The amount of each monthly payment is based on the length of the loan, the amount borrowed and the interest rate. Create an app that allows the customer to enter the price of a car, the down-payment amount and the loan’s annual interest rate. The app should display the loan’s duration in months and the monthly payments for two-, three-, four- and five-year loans. The variety of options allows the user to easily compare repayment plans and choose the most appropriate.

3.9 (Body Mass Index Calculator App) The formulas for calculating the BMI are

or

Create a BMI calculator app that allows users to enter their weight and height and whether they are entering these values in English or Metric units, then calculates and displays the user’s body mass index. The app should also display the following information from the Department of Health and Human Services/National Institutes of Health so the user can evaluate his/her BMI:

Click here to view code image

BMI VALUES
Underweight: less than 18.5
Normal:      between 18.5 and 24.9
Overweight:  between 25 and 29.9
Obese:       30 or greater

3.10 (Target-Heart-Rate Calculator App) While exercising, you can use a heart-rate monitor to see that your heart rate stays within a safe range suggested by your trainers and doctors. According to the American Heart Association (AHA), the formula for calculating your maximum heart rate in beats per minute is 220 minus your age in years (http://bit.ly/AHATargetHeartRates). Your target heart rate is a range that is 50–85% of your maximum heart rate. [Note: These formulas are estimates provided by the AHA. Maximum and target heart rates may vary based on the health, fitness and gender of the individual. Always consult a physician or qualified health care professional before beginning or modifying an exercise program.] Write an app that inputs the person’s age, then calculates and displays the person’s maximum heart rate and target-heart-rate range.