7. WeatherViewer App

• a weather-condition icon

• the day of the week with a text description of that day’s weather

• the day’s low and high temperatures (in °F), and

• the humidity percentage.

The preceding items represent a subset of the returned forecast data. For details of the data returned by the 16-day weather forecast API, visit:

For a list of all weather data APIs provided by OpenWeatherMap.org, visit:

The machine on which a web service resides is the web service host. The client—in this case the WeatherViewer app—sends a request over a network to the web service host, which processes the request and returns a response over the network to the client. This distributed computing benefits systems in various ways. For example, an app can access data on demand via a web service, rather than storing the data directly on the device. Similarly, an app lacking the processing power to perform specific computations could use a web service to take advantage of another system’s superior resources.

• confirm that you have permission to use the web service and

• track your usage—many web services limit the total number of requests you can make in a specific timeframe (e.g., per second, per minute, per hour, etc.).

Some web services require authentication before the web service gives the app an API key—in effect, you log into the web service programmatically, before being allowed to use the web service.

For more information about the license terms, see the Licenses section at

After registering, copy the hexadecimal API key from the confirmation web page, then replace YOUR_API_KEY in strings.xml with the key.

Each property name is a String. Arrays are represented in JSON with square brackets in the following format:

Each array element can be a String, number, JSON object, true, false or null. Figure 7.3 sample JSON returned by OpenWeatherMap.org’s daily forecast web service used in this app—this particular sample contains two days of weather data (lines 15–57).

Click here to view code image

Fig. 7.3 | Sample JSON from the OpenWeatherMap.org daily forecast web service.

There are many properties in the JSON object returned by the daily forecast. We use only the "list" property—an array of JSON objects representing the forecasts for up to 16 days (7 by default, unless you specify otherwise). Each "list" array element contains many properties of which we use:

• "dt"—a long integer containing the date/time stamp represented as the number of seconds since January 1, 1970 GMT. We convert this into a day name.

• "temp"—a JSON object containing double properties representing the day’s temperatures. We use only the minimum ("min") and maximum ("max") temperatures, but the web service also returns the average daytime ("day"), nighttime ("night"), evening ("eve") and morning ("morn") temperatures.

• "humidity"—an int representing the humidity percentage.

• "weather"—a JSON object containing several properties, including a description of the conditions ("description") and the name of an icon that represents the conditions ("icon").

• JSONObject—One of this class’s constructors converts a String of JSON data into a JSONObject containing a Map<String, Object> that maps the JSON keys to their corresponding values. You access the JSON properties in your code via JSONObject’s get methods, which enable you to obtain a JSON key’s value as one of the types JSONObject, JSONArray, Object, boolean, double, int, long or String.

• JSONArray—This class represents a JSON array and provides methods for accessing its elements. The "list" property in the OpenWeatherMap.org response will be manipulated as a JSONArray.

To perform long-running tasks that result in updates to the GUI, Android provides class AsyncTask (package android.os), which performs the long-running operation in one thread and delivers the results to the GUI thread. The details of creating and manipulating threads are handled for you by class AsyncTask, as are communicating the results from the AsyncTask to the GUI thread. We’ll use two AsyncTask subclasses in this app—one will invoke the OpenWeatherMap.org web service (Section 7.7.5) and the other will download a weather-condition image (Section 7.6.5).

To do this, we introduce the view-holder pattern in which you create a class (typically named ViewHolder) containing instance variables for the views that display a ListView item’s data. When a ListView item is created, you also create a ViewHolder object and initialize its instance variables with references to the item’s nested views. You then store that ViewHolder object with the ListView item, which is a View. Class View’s setTag method allows you to add any Object to a View. This Object is then available to you via the View’s getTag method. We’ll specify as the tag the ViewHolder object that contains references to the ListView item’s nested views.

As a new item is about to scroll onto the screen, the ListView checks whether a reusable view is available. If not, we inflate the new item’s view from a layout XML file, then store references to the GUI components in a ViewHolder object. Then we’ll use setTag to set that ViewHolder object as the tag for the ListView item. If there is a reusable item available, we’ll get that item’s tag with getTag, which will return the existing ViewHolder object that was created previously for that ListView item. Regardless of how we obtain the ViewHolder object, we’ll then display data in the ViewHolder’s referenced views.

FloatingActionButton is a subclass of ImageView, which enables a FloatingActionButton to display an image. The material design guidelines suggest that you position a FloatingActionButton at least 16dp from the edges of a phone device and at least 24dp from the edges of a tablet device—the default app templates configure this for you. For more details about how and when you should use a FloatingActionButton, visit:

The Android Design Support Library’s TextInputLayout (package android.support.design.widget) solves this problem. In a TextInputLayout, when the EditText receives the focus, the TextInputLayout animates the hint text from it’s original size to a smaller size that’s displayed above the EditText so that the user can enter data and see the hint (Fig. 7.2). In this app, the EditText receives the focus as the app begins executing, so the TextInputLayout immediately moves the hint above the EditText.

• Application name: WeatherViewer

• 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. Follow the steps in Section 2.5.2 to add an app icon to your project. Also, follow the steps in Section 4.4.3 to configure Java SE 7 support for the project.

Click here to view code image

<uses-permission android:name="android.permission.INTERNET" />

This allows the app to access the Internet, which is required to invoke a web service.

Android does not ask users to grant such permissions, nor can users revoke such permissions from the app. For this reason, your code does not need to check whether the app has a given PROTECTION_NORMAL permission. You must still request these permissions in AndroidManifest.xml, however, for backward compatibility with earlier Android versions.

• activity_main.xml defines the activity’s Toolbar (the app bar replacement in an AppCompatActivity) and a FloatingActionButton, which is positioned in the bottom-right corner by default.

• content_main.xml defines the rest of MainActivity’s GUI and is included in the activity_main.xml file via an <include> element.

Make the following changes to activity_main.xml for this app:

1. Add the id coordinatorLayout to the CoordinatorLayout—you’ll use this to specify the layout in which a Snackbar will be displayed.

2. Add the material design done () button to the project via the Vector Asset Studio (as you did in Section 4.4.9), then specify this new icon for the predefined FloatingActionButton’s src property.

3. Edit the layout’s XML to configure several FloatingActionButton properties that are not available via the Properties window. Change the layout_gravity from bottom|end to top|end so that the FloatingActionButton appears at the top right of the user interface.

4. To move the button to overlap the EditText’s right edge, define a new dimension resource named fab_margin_top with the value 90dp. Using this dimension resource and the fab_margin dimension resource defined by the Blank Activity template to define the following FloatingActionButton margins:

Click here to view code image

5. Finally, remove the FloatingActionButton’s layout_margin that was predefined by the Blank Activity template.

1. Remove the default TextView defined by the Blank Activity template and change the RelativeLayout to a vertical LinearLayout.

2. Next, insert a TextInputLayout. In the layout editor’s Design view, click CustomView in the Custom section. In the dialog that appears, begin typing TextInputLayout to search the list of custom GUI components. Once the IDE highlights TextInputLayout, click OK, then in the Component Tree, click the LinearLayout to insert the TextInputLayout as a nested layout.

3. To add an EditText to the TextInputLayout, switch to the layout editor’s Text view, then change the TextInputLayout element’s closing /> to >, position the cursor to the right of the >, press Enter and type </. The IDE will auto-complete the closing tag. Between the TextInputLayout’s starting and ending tags, type <EditText. The IDE will show an auto-complete window with EditText selected. Press Enter to insert an EditText, then set its layout_width to match_parent and layout_height to wrap_content. In Design view, set the EditText’s id to locationEditText, check its singleLine property’s checkbox and set its hint property to the String resource hint_text.

4. To complete the layout, drag a ListView onto the LinearLayout in the Component Tree. Set its layout:width to match_parent, its layout:height to 0dp, its layout:weight to 1 and its id to weatherListView. Recall that the layout:height value 0dp is recommended by the IDE for more efficient rendering when using the layout:weight to determine a View’s height.

1. Right click the project’s layout folder, and select New > Layout resource file.

2. Enter list_item.xml in the File name field of the New Resource File dialog.

3. Ensure that LinearLayout is specified in the Root element field, then click OK. The list_item.xml file will appear in the layout directory in the Project window and will open in the layout editor.

4. Select the LinearLayout and change its orientation to horizontal—this layout will consist of an ImageView and a GridLayout containing the other views.

1. Drag an ImageView from the Palette onto the LinearLayout in the Component Tree.

2. Set the id to conditionImageView.

3. Set the layout:width to 50dp—define the dimension resource image_side_length for this value.

4. Set the layout:height to match_parent—the ImageView’s height will match the ListView item’s height.

5. Set the contentDescription to the String resource weather_condition_image that you created in Section 7.4.3.

6. Set the scaleType to fitCenter—the icon will fit within the ImageView’s bounds and be centered horizontally and vertically.

1. Drag a GridLayout from the Palette onto the LinearLayout in the Component Tree.

2. Set the columnCount to 3 and the rowCount to 2.

3. Set the layout:width to 0dp—this GridLayout’s width will be determined by the layout:weight.

4. Set the layout:height to match_parent—the GridLayout’s height will match the ListView item’s height.

5. Set the layout:weight to 1—the GridLayout’s width will occupy all remaining horizontal space in its parent LinearLayout.

6. Check the useDefaultMargins property to add the default spacing between the GridLayout’s cells.

1. Drag a Large Text onto the GridLayout in the Component Tree and set its id to dayTextView, its layout:column to 0 and its layout:columnSpan to 3.

2. Drag three Plain TextViews onto the GridLayout in the Component Tree and set their ids to lowTextView, hiTextView and humidityTextView, respectively. Set each of these TextViews’ layout:row to 1 and layout:columnWeight to 1. These TextViews will all appear in the GridLayout’s second row and, because they all have the same layout:columnWeight, the columns will be sized equally.

3. Set lowTextView’s layout:column to 0, hiTextView’s layout:column to 1 and humidityTextView’s layout:column to 2.

This completes the list_item.xml layout. You do not need to change the text property of any of the TextViews—their text will be set programmatically.

• Class Weather (this section) represents one day’s weather data. Class MainActivity will convert the JSON weather data into an ArrayList<Weather>.

• Class WeatherArrayAdapter (Section 7.6) defines a custom ArrayAdapter subclass for binding the ArrayList<Weather> to the MainActivity’s ListView. ListView items are indexed from 0 and each ListView item’s nested views are populated with data from the Weather object at the same index in the ArrayList<Weather>.

• Class MainActivity (Section 7.7) defines the app’s user interface and the logic for interacting with the OpenWeatherMap.org daily forecast web service and processing the JSON response.

In this section, we focus on class Weather.

Click here to view code image

Fig. 7.6 | Weather class package statement, import statements and instance variables.

• The NumberFormat object creates Strings from numeric values. Lines 22–23 configure the object to round floating-point values to whole numbers.

• Line 25 calls our utility method convertTimeStampToDay (Section 7.5.3) to get the String day name and initialize dayOfWeek.

• Lines 26–27 format the day’s minimum and maximum temperature values as whole numbers using the numberFormat object. We append °F to the end of each formatted String, as we’ll request Fahrenheit temperatures—the Unicode escape sequence u00B0 represents the degree symbol (°). The OpenWeatherMap.org APIs also support Kelvin (the default) and Celsius temperature formats.

• Lines 28–29 get a NumberFormat for locale-specific percentage formatting, then use it to format the humidity percentage. The web service returns this percentage as a whole number, so we divide that by 100.0 for formatting—in the U.S. locale, 1.00 is formatted as 100%, 0.5 is formatted as 50%, etc.

• Line 30 initializes the weather condition description.

• Lines 31–32 create a URL String representing the weather condition image for the day’s weather—this will be used to download the image.

Click here to view code image

Fig. 7.7 | Weather class constructor.

• Line 37 gets a Calendar object for manipulating dates and times, then line 38 calls method setTimeInMillis to set the time using the timestamp argument. The timestamp is in seconds so we multiply by 1000 to convert it to milliseconds.

• Line 39 gets the default TimeZone object, which we use to adjust the time, based on the device’s time zone (lines 42–43).

• Line 46 creates a SimpleDateFormat that formats a Date object. The constructor argument "EEEE" formats the Date as just the day name (Monday, Tuesday, etc.). For a complete list of formats, visit:

• Line 47 formats and returns the day name. Calendar’s getTime method returns a Date object containing the time. This Date is passed to the SimpleDateFormat’s format method to get the day name.

Click here to view code image

Fig. 7.8 | Weather method convertTimeStampToDay.

This app’s ListView items require a custom layout. Each item contains an image (the weather-condition icon) and text representing the day, weather description, low temperature, high temperature and humidity. To map weather data to ListView items, we extend class ArrayAdapter (line 23) so that we can override ArrayAdapter method getView to configure a custom layout for each ListView item.

Click here to view code image

Fig. 7.9 | WeatherArrayAdapter class package statement and import statements.

Click here to view code image

Fig. 7.10 | Nested class ViewHolder.

Click here to view code image

Fig. 7.11 | WeatherArrayAdapter class instance variable and constructor.

Click here to view code image

Fig. 7.12 | Overridden ArrayAdapter method getView.

If convertView is null, line 52 creates a new ViewHolder object to store references to a new ListView item’s views. Next, line 53 gets the Context’s LayoutInflator, which we use in lines 54–55 to inflate the ListView item’s layout. The first argument is the layout to inflate (R.layout.list_item), the second is the layout’s parent ViewGroup to which the layout’s views will be attached and the last argument is a boolean indicating whether the views should be attached automatically. In this case, the third argument is false, because the ListView calls method getView to obtain the item’s View, then attaches it to the ListView. Lines 56–65 get references to the views in the newly inflated layout and set the ViewHolder’s instance variables. Line 66 sets the new ViewHolder object as the ListView item’s tag to store the ViewHolder with the ListView item for future use.

If convertView is not null, the ListView is reusing a ListView item that scrolled off the screen. In this case, line 69 gets the current ListView item’s tag, which is the ViewHolder that was previously attached to that ListView item.

After creating or getting the ViewHolder, lines 74–93 set the data for the ListItem’s views. Lines 74–82 determine if the weather-condition image was previously downloaded, in which case the bitmaps object will contain a key for the Weather object’s iconURL. If so, lines 75–76 get the existing Bitmap from bitmaps and set the conditionImageView’s image. Otherwise, lines 80–81 create a new LoadImageTask (Section 7.6.5) to download the image in a separate thread. The task’s execute method receives the iconURL and initiates the task. Lines 86–93 set the Strings for the ListView item’s TextViews. Finally, line 95 returns the ListView item’s configured View.

Click here to view code image

Fig. 7.13 | AsyncTask subclass for downloading images in a separate thread.

AsyncTask is a generic type that requires three type parameters:

• The first is the variable-length parameter-list type (String) for AsyncTask’s doInBackground method, which you must overload (lines 108–136). When you call the task’s execute method, it creates a thread in which doInBackground performs the task. This app passes the weather-condition icon’s URL String as the argument to the AsyncTask’s execute method (Fig. 7.12, lines 80–81).

• The second is the variable-length parameter-list type for the AsyncTask’s onProgressUpdate method. This method executes in the GUI thread and is used to receive intermediate updates of the specified type from a long-running task. Overriding this method is optional. We don’t use it in this example, so we specify type Void here and ignore this type parameter.

• The third is the type of the task’s result (Bitmap), which is passed to AsyncTask’s onPostExecute method (139–143). This method executes in the GUI thread and enables the ListView item’s ImageView to display the AsyncTask’s results. The ImageView to update is specified as an argument to class LoadImageTask’s constructor (lines 103–105) and stored in the instance variable at line 100.

A key benefit of using an AsyncTask is that it handles the details of creating threads and executing its methods on the appropriate threads for you, so that you do not have to interact with the threading mechanism directly.

Click here to view code image

Fig. 7.14 | Class MainActivity’s package statement and import statements.

• weatherList (line 32) is an ArrayList<Weather> that stores the Weather objects—each represents one day in the daily forecast.

• weatherArrayAdapter will refer to a WeatherArrayAdapter object (Section 7.6) that binds the weatherList to the ListView’s items.

• weatherListView will refer to MainActivity’s ListView.

Click here to view code image

Fig. 7.15 | Class MainActivity’s instance variables.

Lines 48–50 configure the weatherListView’s ListAdapter—in this case, an object of the WeatherArrayAdapter subclass of ArrayAdapter. ListView method setAdapter connects the WeatherArrayAdapter to the ListView for populating the ListView’s items.

Click here to view code image

Fig. 7.16 | Overridden Activity method onCreate.

Lines 53–75 configure the FloatingActionButton from the Blank Activity template. The onClick listener method was autogenerated by Android Studio, but we reimplemented its body for this app. We get a reference to the app’s EditText then use it in line 61 to get the user’s input. We pass that to method createURL (Section 7.7.4) to create the URL representing the web service request that will return the city’s weather forecast.

If the URL is created successfully, line 66 programmatically hides the keyboard by calling method dismissKeyboard (Section 7.7.4). Line 67 then creates a new GetWeatherTask to obtain the weather forecast in a separate thread and line 68 executes the task, passing the URL of the web service request as an argument to AsyncTask method execute. If the URL is not created successfully, lines 71–72 create a Snackbar indicating that the URL was invalid.

Click here to view code image

Fig. 7.17 | MainActivity methods dismissKeyboard and createURL.

Method createURL (lines 86–101) assembles the String representation of the URL for the web service request (lines 92–93). Then line 94 attempts to create and return a URL object initialized with the URL String. In line 93, we add parameters to the web service query

The units parameter can be imperial (for Fahrenheit temperatures), metric (for Celsius) or standard (for Kelvin)—standard is the default if you do not include the units parameter. The cnt parameter specifies how many days should be included in the forecast. The maximum is 16 and the default is 7—providing an invalid number of days results in a seven-day forecast. Finally the APPID parameter is for your OpenWeatherMap.org API key, which we load into the app from the String resource api_key. By default, the forecast is returned in JSON format, but you can add the mode parameter with the value XML or HTML, to receive XML formatted data or a web page, respectively.

Click here to view code image

Fig. 7.18 | AsyncTask subclass for invoking a web service.

For class GetWeatherTask the three generic type parameters are:

• URL for the variable-length parameter-list type of AsyncTask’s doInBackground method (lines 108–51)—the URL of the web service request is passed as the only argument to the GetWeatherTask’s execute method.

• Void for the variable-length parameter-list type for the onProgressUpdate method—once again, we do not use this method.

• JSONObject for the type of the task’s result, which is passed to onPostExecute (154–159) in the GUI thread to display the results.

Line 113 in doInBackground creates the HttpURLConnection that’s used to invoke the REST web service. As in Section 7.6.5, simply opening the connection makes the request. Line 114 gets the response code from the web server. If the response code is HttpURLConnection.HTTP_OK, the REST web service was invoked properly and there is a response to process. In this case, lines 119–126 get the HttpURLConnection’s InputStream, wrap it in a BufferedReader, read each line of text from the response and append it to a StringBuilder. Then, line 134 converts the JSON String in the StringBuilder to a JSONObject and return it to the GUI thread. Line 147 disconnects the HttpURLConnection.

If there’s an error reading the weather data or connecting to the web service, lines 129–130, 137–138 or 142–143 display a Snackbar indicating the problem that occurred. These problems might occur if the device loses its network access in the middle of a request or if the device does not have network access in the first place—for example, if the device is in airplane mode.

When onPostExecute is called in the GUI thread, line 156 calls method convertJSONtoArrayList (Section 7.7.6) to extract the weather data from the JSONObject and place it in the weatherList. Then line 157 calls the ArrayAdapter’s notifyDataSetChanged method, which causes the weatherListView to update itself with the new data. Line 158 calls ListView method smoothScrollToPosition to reposition the ListView’s first item to the top of the ListView—this ensures that the new weather forecast’s first day is shown at the top.

Click here to view code image

Fig. 7.19 | MainActivity method convertJSONtoArrayList.

Line 168 obtains the "list" JSONArray by calling JSONObject method getJSONArray with the name of the array property as an argument. Next, lines 171–189 create a Weather object for every element in the JSONArray. JSONArray method length returns the array’s number of elements (line 171).

Next, line 172 gets a JSONObject representing one day’s forecast from the JSONArray by calling method getJSONObject, which receives an index as its argument. Line 175 gets the "temp" JSON object, which contains the day’s temperature data. Lines 178–179 get the "weather" JSON array, then get the array’s first element which contains the day’s weather description and icon.

Lines 182–188 create a Weather object and add it to the weatherList. Line 183 uses JSONObject method getLong to get the day’s timestamp ("dt"), which the Weather constructor converts to the day name. Lines 184–186 call JSONObject method getDouble to get the minimum ("min") and maximum ("max") temperatures from the temperatures object and the "humidity" percentage from the day object. Finally, lines 187–188 use getString to get the weather description and the weather-condition icon Strings from the weather object.

The OpenWeatherMap.org web service used in this app returned the forecast as a String in JavaScript Object Notation (JSON) format. You learned that JSON is a text-based format in which objects are represented as collections of name/value pairs. You used the classes JSONObject and JSONArray from the org.json package to process the JSON data.

To invoke the web service, you converted the web service’s URL String into a URL object. You then used the URL to open an HttpUrlConnection that invoked the web service via an HTTP request. The app read all the data from the HttpUrlConnection’s InputStream and placed it in a String, then converted that String to a JSONObject for processing. We demonstrated how to perform long-running operations outside the GUI thread and receive their results in the GUI thread by using AsyncTask objects. This is particularly important for web-service requests, which have indeterminate response times.

You displayed the weather data in a ListView, using a subclass of ArrayAdapter to supply the data for each ListView item. We showed how to improve a ListView’s performance via the view-holder pattern by reusing existing ListView items’ views as the items scroll off the screen.

Finally, you used several material-design features from the Android Design Support Library’s—a TextInputLayout to keep an EditText’s hint on the screen even after the user began entering text, a FloatingActionButton to enable the user to submit input and a Snackbar to display an informational message to the user.

In Chapter 8, we build the Twitter^® Searches app. Many mobile apps display lists of items, just as we did in this app. In Chapter 8, you’ll do this by using a RecyclerView that obtains data from an ArrayList<String>. For large data sets, RecyclerView is more efficient than ListView. You’ll also store app data as user preferences and learn how to launch the device’s web browser to display a web page.

a) A(n) ____________ is a software component that can be accessed over a network.

b) ____________ refers to an architectural style for implementing web services—often called RESTful web services

c) Classes from the ____________ package process JSON data.

d) To invoke a REST web service, you can use a URL to open a(n) ____________, which makes the HTTP request to the web service.

e) A(n) ____________ (package android.widget) displays a scrollable list of items.

f) A(n) ____________ is a button that floats over the user interface.

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

a) Many of today’s most popular free and fee-based web services are RESTful.

b) REST is a standard protocol.

c) You should perform long-running operations or operations that block execution until they complete (e.g., network, file and database access) outside the GUI thread.

d) JSON (JavaScript Object Notation)—a simple way to represent JavaScript objects as numbers—is an alternative to XML for passing data between the client and the server.

e) Arrays are represented in JSON with curly braces in the following format:

{ value1, value2, value3 }

f) Class JSONObject’s get methods enable you to obtain a JSON key’s value as one of the types JSONObject, JSONArray, Object, boolean, double, int, long or String.

a) web service.

b) Representational State Transfer (REST).

c) org.json.

d) HttpUrlConnection.

e) ListView.

f) FloatingActionButton.

7.2

a) True.

b) False. Though REST itself is not a standard, RESTful web services use web standards, such as HyperText Transfer Protocol (HTTP), which is used by web browsers to communicate with web servers.

c) True.

d) False. JSON (JavaScript Object Notation)—a simple way to represent JavaScript objects as strings—is an alternative to XML for passing data between the client and the server.

e) False. Arrays are represented in JSON with square brackets.

f) True.

a) The machine on which a web service resides is the ____________.

b) Class ____________ provides methods for accessing the elements of a JSON array.

c) To perform long-running tasks that result in updates to the GUI, Android provides class____________ (package android.os), which performs the long-running operation in one thread and delivers the results to the GUI thread.

d) In the ____________ you create a class containing instance variables for the views that display a ListView item’s data. When a ListView item is created, you also create an object of this class and initialize its instance variables with references to the item’s nested views, then store that object with the ListView item.

e) Class JSONObject’s ____________ method returns the String for a given key.

f) ListView is a subclass of ____________, which represents a view that gets its data from a data source via an Adapter object.

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

a) To receive a JSON response from a web service invoked by an HttpUrlConnection, you read from the connection’s InputStream.

b) Each object in JSON is represented as a list of property names and values contained in curly braces, in the following format:

{ "propertyName1" : value1, "propertyName2'": value2 }

c) Each value in a JSON array can be a string, a number, a JSON representation of an object, true, false or null.

d) A ListAdapter populates a ListView using data from an ArrayList collection object.

e) In an EditTextLayout, when the EditText receives the focus, the layout animates the hint text from it’s original size to a smaller size that’s displayed above the EditText.

7.5 (Enhanced Weather Viewer App) Investigate Android’s capabilities for getting a device’s last known location

and the Android class Geocoder

When the app first loads, use these capabilities to prepopulate the app’s EditText with the user’s location and to display the weather for that location.

7.6 (Enhanced Quiz App) Modify the Flag Quiz app in Chapter 4 to create your own quiz app that shows videos rather than images. Possible quizzes could include U.S. presidents, world landmarks, movie stars, recording artists, and more. Consider using YouTube web services (https://developers.google.com/youtube/) to obtain videos for display in the app. (Be sure to read the YouTube API terms of service at https://developers.google.com/youtube/terms.)

7.7 (Word Scramble Game) Create an app that scrambles the letters of a word or phrase and asks the user to enter the correct word or phrase. Keep track of the user’s high score in the app’s SharedPreferences. Include levels (three-, four-, five-, six- and seven-letter words). As a hint to the user, provide a definition with each word. Use an online dictionary’s web services to select the words and the definitions that are used for hints.

7.8 (Crossword Puzzle Generator App) Most people have worked a crossword puzzle, but few have ever attempted to generate one. Create a crossword generator app that use an online dictionary’s web services to select the words and the definitions that are used for hints. Display the corresponding hints when the user touches the first square in a word. If the square represents the beginning of both a horizontal and vertical word, show both hints.

Check out the catalog of web-service APIs at www.programmableweb.com and the apps in Android Market for inspiration. It’s important to read the terms of service for the APIs before building your apps. Some APIs are free while others may charge fees. There also may be restrictions on the frequency with which your app may query the server.

7.9 (Mashup) Use your imagination to create a mashup app using at least two APIs of your choice.

7.10 (News Aggregator App) Use web services to create a news aggregator app that gathers news from multiple sources.

7.11 (Enhanced News Aggregator App) Enhance the News Aggregator app using a maps API. Allow the user to select a region of the world. When the user clicks on a region, display the headlines from the multiple news sources.

7.12 (Shopping Mashup App) Create a location-based shopping app using APIs from CityGrid^® (www.citygridmedia.com/developer/) or a similar shopping service. Add background music to your app using APIs from a service such as Last.fm (www.last.fm/api) so the user can listen while shopping.

7.13 (Daily Deals Mashup App) Create a local daily deals app using Groupon APIs (www.groupon.com/pages/api) or those of a similar service.

7.14 (Idiomatic Expressions Translator Mashup App) An idiomatic expression is a common, often strange saying whose meaning cannot be understood from the words in the expression. For example, you might say your favorite sports team is going to “eat [their opponent] for lunch,” or “blow [their opponent] out of the water” to indicate that you predict your team will win decisively. Search the web to find popular idiomatic expressions. Create an app that allows the user to enter an idiomatic expression by text or speech, then translate the expression into a foreign language and then back to English. Use a translation API (such as Bing) to perform the translation. Allow the user to select the foreign language. Display the results in English—they may be funny or interesting.

7.15 (Name That Song App) Check your favorite music sites to see if they have a web services API. Using a music web services API, create a quiz app (similar to the Flag Quiz app in Chapter 5) that plays a song and asks the user to name the song. Other features to include:

a) Add three lifelines that allow you to call one contact, SMS one contact and e-mail one contact for help answering a question. Once each lifeline is used, disable the capability for that quiz.

b) Add a timer function so that the user must answer each question within 10 seconds.

c) Add multiplayer functionality that allows two users to play on the same device.

d) Add muliplayer functionality to allow users on different devices to compete in the same game.

e) Keep track of the user’s score and display it as a percentage at the bottom of the screen throughout the quiz.