content: package com.example.android.quakereport;
  
  import android.util.Log;
  import android.widget.ListView;
  
  import org.json.JSONArray;
  import org.json.JSONException;
  import org.json.JSONObject;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.net.HttpURLConnection;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  /**
   * Helper methods related to requesting and receiving earthquake data from USGS.
   */
  public final class QueryUtils {
  
      public static final String LOG_TAG = QueryUtils.class.getSimpleName();
  
  
      public static List<Earthquake> fetchEarthquakeData(String requestUrl) {
          // Create URL object
          URL url = createUrl(requestUrl);
  
          // Perform HTTP request to the URL and receive a JSON response back
          String jsonResponse = null;
          try {
              jsonResponse = makeHttpRequest(url);
          } catch (IOException e) {
              Log.e(LOG_TAG, "Error closing input stream", e);
          }
  
          // Extract relevant fields from the JSON response and create an {@link List<Earthquake>} object
          List<Earthquake> earthquakes = extractEarthquakes(jsonResponse);
  
          // Return the {@link List<Earthquake>}
          return earthquakes;
      }
  
      /**
       * Returns new URL object from the given string URL.
       */
      private static URL createUrl(String stringUrl) {
          URL url = null;
          try {
              url = new URL(stringUrl);
          } catch (MalformedURLException e) {
              Log.e(LOG_TAG, "Error with creating URL ", e);
          }
          return url;
      }
  
      /**
       * Make an HTTP request to the given URL and return a String as the response.
       */
      private static String makeHttpRequest(URL url) throws IOException {
          String jsonResponse = "";
  
          // If the URL is null, then return early.
          if (url == null) {
              return jsonResponse;
          }
  
          HttpURLConnection urlConnection = null;
          InputStream inputStream = null;
          try {
              urlConnection = (HttpURLConnection) url.openConnection();
              urlConnection.setReadTimeout(10000 /* milliseconds */);
              urlConnection.setConnectTimeout(15000 /* milliseconds */);
              urlConnection.setRequestMethod("GET");
              urlConnection.connect();
  
              // If the request was successful (response code 200),
              // then read the input stream and parse the response.
              if (urlConnection.getResponseCode() == 200) {
                  inputStream = urlConnection.getInputStream();
                  jsonResponse = readFromStream(inputStream);
              } else {
                  Log.e(LOG_TAG, "Error response code: " + urlConnection.getResponseCode());
              }
          } catch (IOException e) {
              Log.e(LOG_TAG, "Problem retrieving the earthquake JSON results.", e);
          } finally {
              if (urlConnection != null) {
                  urlConnection.disconnect();
              }
              if (inputStream != null) {
                  inputStream.close();
              }
          }
          return jsonResponse;
      }
  
      /**
       * Convert the {@link InputStream} into a String which contains the
       * whole JSON response from the server.
       */
      private static String readFromStream(InputStream inputStream) throws IOException {
          StringBuilder output = new StringBuilder();
          if (inputStream != null) {
              InputStreamReader inputStreamReader = new InputStreamReader(inputStream, Charset.forName("UTF-8"));
              BufferedReader reader = new BufferedReader(inputStreamReader);
              String line = reader.readLine();
              while (line != null) {
                  output.append(line);
                  line = reader.readLine();
              }
          }
          return output.toString();
      }
  
      /**
       * Return a list of {@link Earthquake} objects that has been built up from
       * parsing a JSON response.
       */
      public static ArrayList<Earthquake> extractEarthquakes(String jsonResponse) {
  
          // 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 {
              JSONObject jsonObject = new JSONObject(jsonResponse);
  
              JSONArray features = jsonObject.getJSONArray("features");
              JSONObject properties;
              for (int i = 0; i < features.length(); i++) {
                  properties = features.getJSONObject(i).getJSONObject("properties");
                  earthquakes.add(
                          new Earthquake(
                                  properties.getDouble("mag"),
                                  properties.getString("place"),
                                  properties.getLong("time"),
                                  properties.getString("url")
                          ));
              }
          } 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;
      }
  }