8.1 Introduction

Twitter’s search mechanism makes it easy to follow trending topics being discussed by Twitter’s 300+ million active monthly users¹ (there are over one billion total Twitter accounts²). Searches can be fine-tuned using Twitter’s search operators (Section 8.2), often resulting in lengthy search strings that are time consuming and cumbersome to enter on a mobile device. The Twitter^® Searches app (Fig. 8.1) allows you to save your favorite search queries with easy-to-remember short tag names (Fig. 8.1(a)) that are displayed as a scrollable list. You can then scroll through your saved searches and simply touch a tag name to quickly view tweets on a given topic (Fig. 8.1(b)). As you’ll see, the app also allows you to share, edit and delete saved searches.

8.2 Test-Driving the App

Opening and Running the App

Open Android Studio and open the Twitter Searches app from the TwitterSearches folder in the book’s examples folder, then execute the app in the AVD or on a device. This builds the project and runs the app (Fig. 8.2).

8.2.1 Adding a Favorite Search

Touch the top EditText, then enter from:deitel as the search query—the from: operator locates tweets from a specified Twitter account. Figure 8.3 shows several Twitter search operators—multiple operators can be used to construct more complex queries. A complete list can be found at

8.2.2 Viewing Twitter Search Results

To view the search results, touch the tag “Deitel.” This launches the device’s web browser and passes a URL that represents the saved search to the Twitter website. Twitter obtains the search query from the URL, then returns the tweets that match the query (if any) as a web page. The web browser then displays the results page (Fig. 8.5). When you’re done viewing the results, touch the back button () to return to the Twitter Searches app where you can save more searches, and edit, delete and share previously saved searches. For the "from:deitel" query, Twitter shows relevant user accounts containing deitel in the account name and recent tweets from those accounts.

8.2.3 Editing a Search

You may also share, edit or delete a search. To see these options, long press the search’s tag—that is, touch the tag and keep your finger on the screen until the dialog containing Share, Edit and Delete options appears. If you’re using an AVD, click and hold the left mouse button on the search tag to perform a long press. When you long press “Deitel,” the AlertDialog in Fig. 8.6(a) displays the Share, Edit and Delete options for the search tagged as “Deitel.” If you don’t wish to perform any of these tasks, touch CANCEL.

8.2.4 Sharing a Search

Android makes it easy for you to share various types of information from an app via e-mail, instant messaging (SMS), Facebook, Google+, Twitter and more. In this app, you can share a favorite search by long pressing the search’s tag and selecting Share from the AlertDialog that appears. This displays a so-called intent chooser (Fig. 8.8(a)), which can vary, based on the type of content you’re sharing and the apps that can handle that content. In this app we’re sharing text, and the intent chooser on our phone shows many apps capable of handling text. If no apps can handle the content, the intent chooser will display a message saying so. If only one app can handle the content, that app will launch without you having to select which app to use from the intent chooser. For this test-drive, we touched Gmail. Figure 8.8(b) shows the Gmail app’s Compose screen with the from address, e-mail subject and body pre-populated. We blurred the From email address for privacy in the screen capture.

8.2.5 Deleting a Search

To delete a search, long press the search’s tag and select Delete from the AlertDialog that appears. The app prompts you to confirm that you’d like to delete the search (Fig. 8.9)—touching CANCEL returns you to the main screen without deleting the search. Touching DELETE deletes the search.

8.2.6 Scrolling Through Saved Searches

Figure 8.10 shows the app after we’ve saved several favorite searches—six of which are currently visible. The app allows you to scroll through your favorite searches if there are more than can be displayed on the screen at once. Unlike desktop apps, touch-screen apps do not typically display scrollbars to indicate scrollable areas of the screen. To scroll, simply drag or flick your finger (or the mouse in an AVD) up or down in the list of Tagged Searches. Also, rotate the device to landscape orientation to see that the GUI dynamically adjusts.

8.3 Technologies Overview

This section introduces the features you’ll use to build the Twitter Searches app.

8.3.1 Storing Key–Value Data in a SharedPreferences File

Each app can have SharedPreferences files containing key–value pairs associated with the app—each key enables you to quickly look up a corresponding value. Chapter 4’s Flag Quiz app stored the app’s preferences in a SharedPreferences file on the device. That app’s PreferenceFragment created the SharedPreferences file for you. In this app, you’ll create and manage a SharedPreferences file called searches in which you’ll store the pairs of tags (the keys) and Twitter search queries (the values) that the user creates. Once again, you’ll use a SharedPreferences.Editor to make changes to the tag–query pairs.

8.3.2 Implicit Intents and Intent Choosers

In Chapter 4, you used an explicit Intent to launch a specific Activity in the same app. Android also supports implicit Intents for which you do not specify explicitly which component should handle the Intent. In this app you’ll use two implicit Intents:

8.3.3 RecyclerView

In Chapter 7, you used a ListView to display a weather forecast—a limited set of data. Many mobile apps display extensive lists of information. For example, an e-mail app displays a list of e-mails, an address-book app displays a list of contacts, a news app displays a list of headlines, etc. In each case, the user touches an item in the list to see more information—e.g., the content of the selected e-mail, the details of the selected contact or the text of the selected news story.

RecyclerView vs. ListView

In this app, you’ll display the scrollable list of tagged searches using a RecyclerView (package android.support.v7.widget)—a flexible, customizable view that enables you to control how an app displays a scrolling list of data. RecyclerView was designed as a better ListView. It provides better separation of the data’s presentation from the RecyclerView’s capabilities for reusing views (Section 8.3.4), as well as more flexible customization options (Section 8.3.5) for presenting the RecyclerView’s items. For example, a ListView’s items are always displayed in a vertical list, whereas a RecyclerView has layout managers that can display the items in a vertical list or in a grid. You can even define your own custom layout manager.

RecyclerView Layout Managers

For this app, the RecyclerView will use a LinearLayoutManager—a subclass of RecyclerView.LayoutManager—to specify that the items will appear in a vertical list, and the list items will each display a search’s tag as a String in a TextView. You also can design custom layouts for a RecyclerView’s items.

8.3.4 RecyclerView.Adapter and RecyclerView.ViewHolder

In Chapter 7, we used a subclass of Adapter to bind data to the ListView. We also introduced the view-holder pattern for reusing views that scroll off-screen. Recall that we created a class called ViewHolder (Section 8.6.2) that maintained references to the views in a ListView item. The Adapter subclass stored a ViewHolder object with each ListView item so that we could reuse the ListView item’s views. You’re not required to use this pattern, but doing so is recommended to increase the ListView’s scrolling performance.

8.3.5 RecyclerView.ItemDecoration

Class ListView automatically displays a horizontal line between items, but RecyclerView does not provide any default decorations. To display horizontal lines between the items, you’ll define a subclass of RecyclerView.ItemDecoration that draws divider lines onto the RecyclerView (Section 8.7).

8.3.6 Displaying a List of Options in an AlertDialog

This app enables the user to long touch a RecyclerView item to display an AlertDialog containing a list of options from which the user can select only one. You’ll use an AlertDialog.Builder’s setItems method to specify a String array resource containing names of the option to display and to set the event handler that’s called when the user touches one of the options.

8.4 Building the App’s GUI and Resource Files

In this section, you’ll build the Twitter Searches app’s GUI and resource files. Recall from Section 8.3.3 that RecyclerView does not define how to render its list items. So you’ll also create a layout that defines a list item’s GUI. The RecyclerView will inflate this layout as necessary when creating list items.

8.4.1 Creating the Project

Create a new project using the Blank Activity template. Fragments are not required for this app, so when you configure the Blank Activity, do not check the Use a Fragment checkbox. Specify the following values in the Create New Project dialog’s New Project step:

8.4.2 AndroidManifest.xml

Most users will launch this app so that they can perform an existing saved search. When the first focusable GUI component in an activity is an EditText, Android gives that component the focus when the activity is displayed. When an EditText receives the focus, its corresponding virtual keyboard is displayed unless a hardware keyboard is present. In this app, we want to prevent the soft keyboard from being displayed until the user touches one of the app’s EditTexts. To do so, follow the steps in Section 3.7 for setting the windowSoftInputMode option, but set its value to stateAlwaysHidden.

8.4.3 Adding the RecyclerView Library

This app uses new material-design user-interface components from the Android Design Support Library, including the TextInputLayout, FloatingActionButton, and the RecyclerView. Android Studio’s new app templates are already configured with Android Design Support Library support for TextInputLayout and FloatingActionButton. To use RecyclerView, however, you must update the app’s dependencies to include the RecyclerView library:

8.4.4 colors.xml

For this app, we changed the app’s default accent color (used for the EditTexts, TextInputLayouts and FloatingActionButton) and added a color resource for the background color in the Tagged Searches area of the screen. Open colors.xml and replace the hexadecimal value for the colorAccent resource with #FF5722, then add a new color resource named colorTaggedSearches with the value #BBDEFB.

8.4.5 strings.xml

Add the String resources in Fig. 8.11 to strings.xml.

8.4.6 arrays.xml

Recall from Chapter 4 that array resources are normally defined in arrays.xml. Follow the steps in Section 4.4.6 to create an arrays.xml file, then add the resource in (Fig. 8.12) to the file.

8.4.7 dimens.xml

Add the dimension resource shown in Fig. 8.13 to the dimens.xml file.

8.4.8 Adding the Save Button Icon

Use Android Studio’s Vector Asset Studio (Section 4.4.9) to add the material design save icon (; located in the Content group) to the project—this will be used as the FloatingActionButton’s icon. After adding the vector icon, go to the project’s res/drawable folder, open the icon’s XML file and change the <path> element’s android:fillColor value to

8.4.9 activity_main.xml

In this section, you’ll customize the FloatingActionButton that’s built into Android Studio’s Blank Activity app template. By default, the button contains an email icon and is positioned the bottom-right of MainActivity’s layout. You’ll replace the email icon with the save icon that you added in Section 8.4.8 and reposition the button at the layout’s top right. Perform the following steps:

8.4.10 content_main.xml

The RelativeLayout in this app’s content_main.xml contains two TextInputLayouts and a LinearLayout that, in turn, contains a TextView and a RecyclerView. Use the layout editor and the Component Tree window to form the layout structure shown in Fig. 8.14. As you create the GUI components, set their ids as specified in the figure. There are several components in this layout that do not require ids, as the app’s Java code does not reference them directly.

Step 1: Adding the queryTextInputLayout and Its Nested EditText

Add the queryTextInputLayout and its nested EditText as follows:

Step 2: Adding the tagTextInputLayout and Its Nested EditText

Using the techniques from the previous step, add the tagTextInputLayout and its nested EditText, with the following changes:

Step 3: Adding the LinearLayout

Next, add a LinearLayout below the tagTextInputLayout:

Step 3: Adding the LinearLayout’s Nested TextView and RecyclerView

Finally, add the LinearLayout’s nested TextView and RecyclerView:

8.4.11 RecyclerView Item’s Layout: list_item.xml

When populating a RecyclerView with data, you must specify each list item’s layout. The list items in this app each display the tag name of one saved search. You’ll now create a new layout that contains only a TextView with the appropriate formatting. Perform the following steps:

Other Predefined Android Resources

There are many predefined Android resources like the ones used to set the height and textAppearance for a list item. You can view the complete list at:

8.5 MainActivity Class

This app consists of three classes:

8.5.1 package and import Statements

Figure 8.15 shows MainActivity’s package and import statements. We discuss the imported types in Section 8.3 and as we encounter them in class MainActivity.

8.5.2 MainActivity Fields

As in the WeatherViewer app, class MainActivity (Fig. 8.16) extends AppCompatActivity (line 32) so that it can display an app bar and use other AppCompat library features on devices running past or current Android versions. The static String constant SEARCHES (line 34) represents the name of a SharedPreferences file that will store tag–query pairs on the device.

8.5.3 Overriden Activity Method onCreate

Overridden Activity method onCreate (Fig. 8.17) initializes the Activity’s instance variables and configures the GUI components. Lines 52–57 obtain references to the queryEditText and tagEditText and, for each, register a TextWatcher (Section 8.5.4) that’s notified when the user enters or removes characters in the EditTexts.

Getting a SharedPreferences Object

Line 60 uses the method getSharedPreferences (inherited indirectly from class Context) to get a SharedPreferences object that can read existing tag–query pairs (if any) from the searches file. The first argument indicates the name of the file that contains the data. The second argument specifies the file’s access-level and can be set to:

Getting the Keys Stored in the SharedPreferences Object

We’d like to display the search tags alphabetically so the user can easily find a search to perform. First, line 63 gets the Strings representing the keys in the SharedPreferences object and stores them in tags (an ArrayList<String>). SharedPreferences method getAll returns all the saved searches as a Map (package java.util)—a collection of key–value pairs. We then call method keySet on the Map object to get all the keys as a Set<String> (package java.util)—a collection of unique values. The result is used to initialize tags.

Sorting the ArrayList of Tags

Line 64 uses Collections.sort to sort tags. Since the user could enter tags using mixtures of uppercase and lowercase letters, we perform a case-insensitive sort by passing the predefined Comparator<String> object String.CASE_INSENSITIVE_ORDER as the second argument to Collections.sort.

Configuring the RecyclerView

Lines 67–79 configure the RecyclerView:

Registering a Listener for the FloatingActionButton

Lines 82–85 obtain a reference to the saveFloatingActionButton and register its OnClickListener. Instance variable saveButtonListener refers to an anonymous-inner-class object that implements interface View.OnClickListener (Section 8.5.5). Line 85 calls method updateSaveFAB (Section 8.5.4), which initially hides the saveFloatingActionButton, because the EditTexts are empty when onCreate is first called—the button displays only when both EditTexts contain input.

8.5.4 TextWatcher Event Handler and Method updateSaveFAB

Figure 8.18 defines an anonymous inner class that implements interface TextWatcher (lines 89–103). The TextWatcher’s onTextChanged method calls updateSaveFAB when the contents change in either of the app’s EditTexts. Lines 54 and 57 (Fig. 8.17) register the instance variable textWatcher as the listener for the EditTexts events.

8.5.5 saveButton’s OnClickListener

Figure 8.19 defines instance variable saveButtonListener, which refers to an anonymous inner class object that implements the interface OnClickListener. Line 84 (Fig. 8.17) registered saveButtonListener as the saveFloatingActionButton’s event handler. Lines 119–135 (Fig. 8.19) override interface OnClickListener’s onClick method. Lines 121–122 get the Strings from the EditTexts. If the user entered a query and a tag (line 124):

8.5.6 addTaggedSearch Method

The event handler in Fig. 8.19 calls method addTaggedSearch (Fig. 8.20) to add a new search to savedSearches or to modify an existing search.

Editing a SharedPreferences Object’s Contents

Recall from Section 4.6.7 that to change a SharedPreferences object’s contents, you must first call its edit method to obtain a SharedPreferences.Editor object (Fig. 8.20, line 141), which can add key–value pairs to, remove key–value pairs from and modify the value associated with a particular key in a SharedPreferences file. Line 142 calls SharedPreferences.Editor method putString to save the search’s tag (the key) and query (the corresponding value)—if the tag already exists in the SharedPreferences this updates the value. Line 143 commits the changes by calling SharedPreferences.Editor method apply to make the changes to the file.

Notifying the RecyclerView.Adapter That Its Data Has Changed

When the user adds a new search, the RecyclerView should be updated to display it. Line 146 determines whether a new tag was added. If so, lines 147–148 add the new search’s tag to tags, then sort tags. Line 149 calls the RecyclerView.Adapter’s notifyDataSetChanged method to indicate that the underlying data in tags has changed. As with a ListView adapter, the RecyclerView.Adapter then notifies the RecyclerView to update its list of displayed items.

8.5.7 Anonymous Inner Class That Implements View.OnClickListener to Display Search Results

Figure 8.21 defines instance variable itemClickListener, which refers to an anonymous inner-class object that implements interface OnClickListener (a nested interface of class View). Lines 156–168 override the interface’s onClick method. The method’s argument is the View that the user touched—in this case, the TextView that displays a search tag in the RecyclerView.

Getting String Resources

Line 159 gets the text of the View that the user touched in the RecyclerView—this is the tag for a search. Lines 160–161 create a String containing the Twitter search URL and the query to perform. Line 160 calls Activity’s inherited method getString with one argument to get the String resource named search_URL, then we append the query String to it.

Getting Strings from a SharedPreferences Object

We append the result of line 161 to the search URL to complete the urlString. SharedPreferences method getString returns the query associated with the tag. If the tag does not already exist, the second argument ("" in this case) is returned. Line 161 passes the query to Uri method encode, which escapes any special URL characters (such as ?, /, :, etc.) and returns a so-called URL-encoded String. Class Uri (uniform resource identifier) of package android.net enables us to convert a URL into the format required by an Intent that launches the device’s web browser.⁴ This is important to ensure that the Twitter web server that receives the request can parse the URL properly to obtain the search query.

Creating an Intent to Launch the Device’s Web Browser

Lines 164–165 create a new Intent, which we’ll use to launch the device’s web browser and display the search results. In Chapter 4, you used an explicit Intent to launch another activity in the same app. Here you’ll use an implicit Intent to launch another app. The first argument of Intent’s constructor is a constant describing the action to perform. Intent.ACTION_VIEW indicates that we’d like to display a representation of the Intent’s data. Many constants are defined in the Intent class describing actions such as searching, choosing, sending and playing:

Starting an Activity for an Intent

Line 167 passes the Intent to the inherited Activity method startActivity, which starts an Activity that can perform the specified action for the given data. In this case, because we’ve specified to view a URI, the Intent launches the device’s web browser to display the corresponding web page. This page shows the results of the supplied Twitter search.

8.5.8 Anonymous Inner Class That Implements View.OnLongClickListener to Share, Edit or Delete a Search

Figure 8.22 defines instance variable itemLongClickListener, which refers to an anonymous inner-class object that implements interface OnLongClickListener. Lines 175–216 override interface OnLongClickListener’s onLongClick method.

final Local Variables for Use in Anonymous Inner Classes

Line 178 assigns to final local variable tag the text of the item the user long pressed—final is required for any local variable or method parameter used in an anonymous inner class.

AlertDialog That Displays a List of Items

Lines 181–186 create an AlertDialog.Builder and set the dialog’s title to a formatted String (R.string.share_edit_delete_title) in which tag replaces the format specifier. Line 186 calls Activity’s inherited method getString that receives multiple arguments—a String resource ID representing a format String and the values that should replace the format specifiers in the format String. In addition to buttons, an AlertDialog can display a list of items. Lines 189–209 use AlertDialog.Builder method setItems to specify that the dialog should display the array of Strings R.array.dialog_items and to define an anonymous inner class object that responds when the user touches any item in the list.

Event Handler for the Dialog’s List of Items

The anonymous inner class in lines 190–208 determines which item the user selected in the dialog’s list and performs the appropriate action. If the user selects Share, shareSearch is called (line 195). If the user selects Edit, lines 199–201 display the search’s query and tag in the EditTexts. If the user selects Delete, deleteSearch is called (line 204).

Configuring the Negative Button and Displaying the Dialog

Line 212 configures the dialog’s negative button. When the negative button’s event handler is null, touching the negative button simply dismisses the dialog. Line 214 creates and shows the dialog.

8.5.9 shareSearch Method

Method shareSearch (Fig. 8.23) is called when the user selects to share a search (Fig. 8.22). Lines 222–223 create a String representing the search to share. Lines 226–232 create and configure an Intent that allows the user to send the search URL using an Activity that can handle the Intent.ACTION_SEND.

Adding Extras to an Intent

An Intent includes a Bundle of extras—additional information that’s passed to the Activity that handles the Intent. For example, an e-mail Activity can receive extras representing the e-mail’s subject, CC and BCC addresses, and the body text. Lines 228–231 use Intent method putExtra to add to the Intent’s Bundle key–value pairs representing the extras. The method’s first argument is a String key representing the purpose of the extra and the second argument is the corresponding extra data. Extras may be primitive type values, primitive type arrays, entire Bundle objects and more—see class Intent’s documentation for a complete list of the putExtra overloads.

Displaying an Intent Chooser

To display the intent chooser shown in Fig. 8.8(a), we pass the Intent and a String title to Intent’s static createChooser method (lines 235–236). The intent chooser’s title is specified by the second argument (R.string.share_search). It’s important to set this title to remind the user to select an appropriate Activity. You cannot control the apps installed on a user’s phone or the Intent filters that can launch those apps, so it’s possible that incompatible activities could appear in the chooser. Method createChooser returns an Intent that we pass to startActivity to display the intent chooser.

8.5.10 deleteSearch Method

The deleteSearch method (Fig. 8.24) is called when the user long presses a search tag and selects Delete from the dialog displayed by the code in Fig. 8.22. Before deleting the search, the app displays an AlertDialog to confirm the delete operation. Line 243 (Fig. 8.24) sets the dialog’s title to a formatted String in which tag replaces the format specifier in the String resource R.string.confirm_message. Line 246 configures the dialog’s negative button to dismiss the dialog. Lines 249–264 configure the dialog’s positive button to remove the search. Line 252 removes the tag from the tags collection, and lines 255–258 use a SharedPreferences.Editor to remove the search from the app’s SharedPreferences. Line 261 then notifies the RecyclerView.Adapter that the underlying data has changed so that the RecyclerView can update its displayed list of items.

8.6 SearchesAdapter Subclass of RecyclerView.Adapter

This section presents the RecyclerView.Adapter that binds the items in MainActivity’s List<String> named tags to the app’s RecyclerView.

8.6.1 package Statement, import statements, Instance Variables and Constructor

Figure 8.25 shows the beginning of class SearchesAdapter’s definition. The class extends generic class RecyclerView.Adapter, using as its type argument the nested class SearchesAdapter.ViewHolder (defined in Section 8.6.2). The instance variables in lines 17–18 maintain references to the event listeners (defined in class MainActivity) that are registered for each RecyclerView item. The instance variable in line 21 maintains a reference to MainActivity’s List<String> that contains the tag names to display.

8.6.2 Nested ViewHolder Subclass of RecyclerView.ViewHolder

Every item in a RecyclerView must be wrapped in its own RecyclerView.ViewHolder. For this app, we defined a RecyclerView.ViewHolder called ViewHolder (Fig. 8.26). The ViewHolder constructor (line 39–48) receives a View object and listeners for that View’s OnClick and OnLongClick events. The View represents an item in the RecyclerView, which is passed to the superclass’s constructor (line 42). Line 43 stores a reference to the TextView for the item. Line 46 registers the TextView’s OnClickListener, which displays the search results for that TextView’s tag. Line 47 registers the TextView’s OnLongClickListener, which opens the Share, Edit or Delete dialog for that TextView’s tag. The constructor is called when the RecyclerView.Adapter creates a new list item method onCreateViewHolder (Section 8.6.3).

8.6.3 Overridden RecyclerView.Adapter Methods

Figure 8.27 defines the overridden RecyclerView.Adapter methods onCreateViewHolder (lines 52–61), onBindViewHolder (lines 64–67) and getItemCount (lines 70–73).

Overriding the onCreateViewHolder Method

The RecyclerView calls its RecyclerView.Adapter’s onCreateViewHolder method (lines 52–61) to inflate the layout for each RecyclerView item (lines 56–57) and wrap it in an object of the RecyclerView.ViewHolder subclass named ViewHolder (line 60). This new ViewHolder object is then returned to the RecyclerView for display.

Overriding the onBindViewHolder Method

The RecyclerView calls its RecyclerView.Adapter’s onBindViewHolder method (lines 64–67) to set the data that’s displayed for a particular RecyclerView item. The method receives:

Overriding the getItemCount Method

The RecyclerView calls its RecyclerView.Adapter’s getItemCount method (lines 70–73) to obtain the total number of items that that the RecyclerView needs to display—in this case, the number of items in tags (line 72).

8.7 ItemDivider Subclass of RecyclerView.ItemDecoration

A RecyclerView.ItemDecoration object draws decorations—such as separators between items—on a RecyclerView. The RecyclerView.ItemDecoration subclass ItemDivider (Fig. 8.28) draws divider lines between list items. Lines 17–18 in the constructor obtain the predefined Android Drawable resource android.R.attr.listDivider, which is the standard Android list-item divider used by default in ListViews.

Overriding the onDrawOver Method

As the user scrolls through the RecyclerView’s items, the RecyclerView’s contents are repeatedly redrawn to display the items in their new positions on the screen. As part of this process, the RecyclerView calls its RecyclerView.ItemDecoration’s onDrawOver method (lines 22–44) to draw the decorations on the RecyclerView. The method receives:

8.8 A Note on Fabric: Twitter’s New Mobile Development Platform

In Chapter 7, you used REST web services to obtain a weather forecast. Twitter provides extensive REST web services that enable you to integrate Twitter functionality into your apps. Using these web services requires a Twitter developer account and special authentication. The focus of this chapter is not on how to use Twitter’s web services. For this reason, the app performs searches as if you enter them directly on the Twitter website in the web browser. The Twitter website then returns the results directly to the device’s web browser for display.

8.9 Wrap-Up

In this chapter, you created the Twitter Searches app. You used a SharedPreferences file to store and manipulate key–value pairs representing the user’s saved Twitter searches.

Self-Review Exercises

8.1 Fill in the blanks in each of the following statements:

Answers to Self-Review Exercises

8.1

Exercises

8.1 Fill in the blanks in each of the following statements:

Project Exercises

8.3 (Favorite Websites App) Using the techniques you learned in this chapter, create a Favorite Websites app that allows a user to create a list of favorite websites.

Advanced Project Exercises

8.10 (Blackjack App) Create a Blackjack card game app. Two cards each are dealt to the dealer and the player. (We provide card images with the book’s examples.) The player’s cards are dealt face up. Only the dealer’s first card is dealt face up. Each card has a value. A card numbered 2 through 10 is worth its face value. Jacks, queens and kings each count as 10. Aces can count as 1 or 11—whichever value is more beneficial to the player. If the sum of the player’s two initial cards is 21 (that is, the player was dealt a card valued at 10 and an ace, which counts as 11 in this situation), the player has “blackjack” and the dealer’s face-down card is revealed. If the dealer does not have blackjack, the player immediately wins the game; otherwise, the hand is a “push” (that is, a tie) and no one wins the hand. If the player does not have blackjack, the player can begin taking additional cards one at a time. These cards are dealt face up, and the player decides when to stop taking cards. If the player “busts” (that is, the sum of the player’s cards exceeds 21), the game is over, and the player loses. When the player stands (stops taking cards), the dealer’s hidden card is revealed. If the dealer’s total is 16 or less, the dealer must take another card; otherwise, the dealer must stay. The dealer must continue to take cards until the sum of the dealer’s cards is greater than or equal to 17. If the dealer exceeds 21, the player wins. Otherwise, the hand with the higher point total wins. If the dealer and the player have the same point total, the game is a “push,” and no one wins. The GUI for this app can be built using ImageViews, TextViews and Buttons.