Json File
Json file
Project address: QuakeReport-github
About this course
Build a earthquake app.
- Where to find the earthquake data.
- API: application programming interface.
- Earthquake data from the USGS
How to describe earthquake
magnitude, epicenter, depth, date, and so on.
Json: packaged data
URL format
In the API Documentation we can see that the URL format: https://earthquake.usgs.gov/fdsnws/event/1/[METHOD[?PARAMETERS]]. There are many Methods we can use. For example, we use query method to submit a data request. query method has many parameters to indicate the query time and other search condition.
This will return a GEOJson file.
Json format
Display Earthquake information
After import the code from github, we do some changes. The app will looks like below.
Add Earthquake class
We need a class to store the information of an earthquake, including magnitude, Location and date.
// a float number to store the magnitude.
private float mMagnitude;
// a String value to store the location
private String mLocation;
// a String value to store the date in the format "Feb 2, 2016"
private String mDate;
In this class, There should be a constructor to set the value of the three variables.
/**
*
* @param magnitude the magnitude of the earthquake
* @param location the location of the earthquake, maybe a city name
* @param date the date of the earthquake in the format "Feb 2, 2016"
*/
public Earthquake(float magnitude, String location, String date) {
mMagnitude = magnitude;
mLocation = location;
mDate = date;
}
Then, We have the getter method to get the value.
/**
*
* @return return magnitude
*/
public float getmMagnitude() {
return mMagnitude;
}
/**
*
* @return return date
*/
public String getmDate() {
return mDate;
}
/**
*
* @return return location
*/
public String getmLocation() {
return mLocation;
}
Add EarthquakeAdapter
Then, we need the Adapter to show the information on the screen.
create the file EarthquakeAdapter.java.
Constructor
We use our custom constructor because we use our list_item view.
/**
* This is our custom constructor,
* The context is used to inflate the layout file,
* and the list is the data we want to populate into the lists.
* @param context The current context. Used to inflate the layout file.
* @param earthquakes A List of Earthquake objects to display in a list
*/
public EarthquakeAdapter(Activity context, ArrayList<Earthquake> earthquakes){
// the second parameter is 0 to indicate we will use our custom list item view to show.
super(context, 0, earthquakes);
}
getView()
- Inflate the view
- get data using
getItem(position) - set data
Json
GEOJson is a special flavor of JSON.
Json: JavaScript Object Notation
Brace, Key Value pairing
Parsing Json in Android
Class JSONObject
Example:
Json file:
{
"candies":[
{
"name":"Jelly Beans",
"count":10
}
]
}
Android code:
String candyJson = "{\"candies\":[{\"name\":\"Jelly Beans\",\"count\":10}]}";
JSONObject root = new JSONObject(candyJson);
JSONArray candiesArray = root.getJSONArray("candies");
JSONObject firstCandy = candiesArray.getJSONObject(0);
String name = firstCandy.getString("name");
int count = firstCandy.getInt("count");
Android provides four different classes to manipulate JSON data. JSONArray, JSONObject, JSONStringer and JSONTokenizer.
JSON Elements
| Str.No | Component & description |
|---|---|
| 1 |
Array: [] <p>In a JSON file, square bracket [] represents a JSON array |
| 2 |
Objects: {} <p>In a JSON file, curly bracket {} represents a JSON object |
| 3 | Key <p>A JSON object contains a key that is just a string. Pairs of key/value make up JSON object. |
| 4 | Value <p>Each key has a value that could be string, integer or double, etc. |
JSON Parsing
For parsing a JSON object, we will create an object of class JSONObject and specify a string containing JSON data to it.
String in;
JSONObject reader = new JSONObject(in);
| Str.No | Method & description |
|---|---|
| 1 | get(String name) <p>This method just Returns the value but in the format of Object type. |
| 2 | getBoolean(String name) <p>This method returns the boolean value specified by the key. |
| 3 | getDouble(String name) <p>This method returns the double value specified by the key. |
| 4 | getInt(String name) <p>This method returns the integer value specified by the key |
| 5 | getLong(String name) <p>This method returns the long value specified by the key |
| 6 | length() <p>This method returns the number of name/value mappings in this object. |
| 7 | names() <p>This method returns an array containing the string names in this object. |
QuakeUtil.java
We create a java class QuakeUtil.java to do something for quake data.
Constructor
This util class is only directly accessed from the class name, so we need the private constructor. There will be no object.
/**
* Create a private constructor because no one should ever create a {@link QueryUtils} object.
* This class is only meant to hold static variables and methods, which can be accessed
* directly from the class name QueryUtils (and an object instance of QueryUtils is not needed).
*/
private QueryUtils() {
}
extractEarthquakes()
This method will Get the information from JSON and add the item to an ArrayList<Earthquake>.
/**
* Return a list of {@link Earthquake} objects that has been built up from
* parsing a JSON response.
*/
public static ArrayList<Earthquake> extractEarthquakes() {
// Create an empty ArrayList that we can start adding earthquakes to
ArrayList<Earthquake> earthquakes = new ArrayList<>();
// Try to parse the SAMPLE_JSON_RESPONSE. If there's a problem with the way the JSON
// is formatted, a JSONException exception object will be thrown.
// Catch the exception so the app doesn't crash, and print the error message to the logs.
try {
// Parse the response given by the SAMPLE_JSON_RESPONSE string and
// build up a list of Earthquake objects with the corresponding data.
JSONObject root = new JSONObject(SAMPLE_JSON_RESPONSE);
JSONArray features = root.getJSONArray("features");
for (int i = 0; i < features.length(); i++) {
JSONObject earthquake = features.getJSONObject(i);
JSONObject properties = earthquake.getJSONObject("properties");
double mag = properties.getDouble("mag");
String place = properties.getString("place");
long time = properties.getLong("time");
earthquakes.add(new Earthquake(Double.toString(mag), place, Long.toString(time)));
}
} catch (JSONException e) {
// If an error is thrown when executing any of the above statements in the "try" block,
// catch the exception here, so the app doesn't crash. Print a log message
// with the message from the exception.
Log.e("QueryUtils", "Problem parsing the earthquake JSON results", e);
}
// Return the list of earthquakes
return earthquakes;
}
Show Earthquake date and time
In our app now, it shows the Unix time. We can use class SimpleDateFormat and Date to convert the time from Unix time to what we need.
Time format:
yyyy-MM-dd HH:mm:ss:
ymeans year.yyyy: 2016
Mmeans mounth.MM: 03
dmeans day.dd: 10
Hhour
mminute
ssecond
- Create a
Dateclass. - Use class
SimpleDateFormatto create adate formatter. - Use this
date formatterto format theDateobject and output a String.
// time in ms format
long timeInMilliseconds = 1454124312220L;
// create Date object
Date dateObject = new Date(timeInMilliseconds);
// create the SimpleDateFormat object dateFormatter
SimpleDateFormat dateFormatter = new SimpleDateFormat("MMM DD, yyyy");
// Format the time
String dateToDisplay = dateFormatter.format(dateObject);
split the location and offset
The location we can get from JSON file is like "64km NNE of Tomatlan, Mexico" or "Pacific-AntarcticRidge"
We need to split the String to two part. "64km NNE of" and "Tomatlan, Mexico"
we use the method split of String.
private static final String LOCATION_SEPARATOR = "of";
...
String[] split_location = location.split("(?<=" + LOCATION_SEPARATOR + ")");
We can judge if the String contains LOCATION_SEPARATOR to decide whether the String can be split.
if (location.contains(LOCATION_SEPARATOR)) {
String[] split_location = location.split("(?<=" + LOCATION_SEPARATOR + ")");
locationOffsetToDisplay = split_location[0];
locationToDisplay = split_location[1];
} else {
locationOffsetToDisplay = getContext().getString(R.string.near_the);
locationToDisplay = location;
}
Format the mag number
0 表示数字的占位符、# 也表示 数字，但是不显示前导零
