Beispiel #1
0
  private static List<Address> parseResults(
      final int maxResults, final boolean parseAddressComponents, @NonNull final JSONObject o)
      throws JSONException {
    final JSONArray results = o.getJSONArray(RESULTS);
    final int count = results.length() >= maxResults ? maxResults : results.length();
    final ArrayList<Address> addressList = new ArrayList<>(count);
    for (int i = 0; i < count; i++) {

      final Address address = new Address();
      final JSONObject result = results.getJSONObject(i);

      if (result.has(FORMATTED_ADDRESS)) {
        address.setFormattedAddress(result.getString(FORMATTED_ADDRESS));
      }

      parseGeometry(result, address);

      if (parseAddressComponents) {
        parseAddressComponents(result, address);
      }

      addressList.add(address);
    }
    return addressList;
  }
  public Reitti lueReitti(File tiedosto) {
    JSONObject obj = this.lataaJsonObject(tiedosto);
    JSONArray arr = obj.getJSONArray("features");

    double[] lat = new double[arr.length()];
    double[] lon = new double[arr.length()];
    int[] aika = new int[arr.length()];

    for (int i = 0; i < arr.length(); i++) {
      JSONArray piste = arr.getJSONObject(i).getJSONObject("geometry").getJSONArray("coordinates");
      lat[i] = piste.getDouble(1);
      lon[i] = piste.getDouble(0);

      String aikaString = arr.getJSONObject(i).getJSONObject("properties").getString("time");

      DateFormat format = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss", Locale.ENGLISH);
      Date timestamp = null;
      try {
        timestamp = format.parse(aikaString);
      } catch (ParseException ex) {
        System.out.println("format ex");
      }
      int sekunnit = (int) timestamp.getTime() / 1000;
      aika[i] = sekunnit;
    }
    Reitti reitti = new Reitti(lon, lat, aika);
    return reitti;
  }
  public void refreshAllStories() {
    // get all topics
    if (!user.has("topics")) {
      swipeLayout.setRefreshing(false);
      return;
    }

    try {
      for (int i = 0; i < topics.length(); i++) {
        JSONObject topic = topics.getJSONObject(i);
        JSONArray topicWords = topic.getJSONObject("modifiedTopicWords").names();
        String urlParams = "";
        for (int j = 0; j < topicWords.length(); j++) {
          String curr = topicWords.getString(j);
          curr = curr.replaceAll("\\s+", "+");
          urlParams += ("words=" + curr + "&");
        }
        long timestamp = topic.getLong("lastTimeStamp");
        urlParams += ("timestamp=" + timestamp);
        String category = topic.getString("category");
        urlParams += ("&category=" + category);
        Log.d("SVF", "Would send: " + urlParams);
        new DownloadNextArticleData().execute(urlParams, Integer.toString(i));
      }
    } catch (JSONException e) {
      e.printStackTrace();
    }
  }
  public static ArrayList<ContentProviderOperation> quoteJsonToContentVals(String JSON)
      throws JSONException {
    ArrayList<ContentProviderOperation> batchOperations = new ArrayList<>();
    JSONObject jsonObject = null;
    JSONArray resultsArray = null;
    ContentProviderOperation cpo = null;

    jsonObject = new JSONObject(JSON);
    if (jsonObject != null && jsonObject.length() != 0) {
      jsonObject = jsonObject.getJSONObject(QUERY);
      int count = Integer.parseInt(jsonObject.getString(COUNT));
      if (count == 1) {
        jsonObject = jsonObject.getJSONObject(RESULTS).getJSONObject(QUOTE);
        cpo = buildBatchOperation(jsonObject);
        if (cpo != null) {
          batchOperations.add(cpo);
        }

      } else {
        resultsArray = jsonObject.getJSONObject(RESULTS).getJSONArray(QUOTE);

        if (resultsArray != null && resultsArray.length() != 0) {
          for (int i = 0; i < resultsArray.length(); i++) {
            jsonObject = resultsArray.getJSONObject(i);
            cpo = buildBatchOperation(jsonObject);
            if (cpo != null) {
              batchOperations.add(cpo);
            }
          }
        }
      }
    }

    return batchOperations;
  }
 private Movie[] getMovieData(String movies_detail) {
   final String RESULTS = "results";
   final String TITLE = "original_title";
   final String OVER_VIEW = "overview";
   final String POSTER_PATH = "poster_path";
   final String RELEASE_DATE = "release_date";
   final String RATINGS = "vote_average";
   Movie[] movies = null;
   try {
     JSONObject movie_json = new JSONObject(movies_detail);
     JSONArray movieArray = movie_json.getJSONArray(RESULTS);
     movies = new Movie[movieArray.length()];
     for (int i = 0; i < movieArray.length(); i++) {
       JSONObject movieObject = movieArray.getJSONObject(i);
       Movie temp_movie = new Movie();
       temp_movie.setTitle(movieObject.getString(TITLE));
       temp_movie.setImage_base_url(movieObject.getString(POSTER_PATH));
       temp_movie.setOverview(movieObject.getString(OVER_VIEW));
       temp_movie.setRatings(movieObject.getDouble(RATINGS));
       temp_movie.setRelease_date(movieObject.getString(RELEASE_DATE));
       movies[i] = temp_movie;
     }
   } catch (Exception e) {
     Log.e("main", e.getMessage());
   }
   return movies;
 }
 private MediaConstraints constraintsFromJSON(String jsonString) throws JSONException {
   if (jsonString == null) {
     return null;
   }
   MediaConstraints constraints = new MediaConstraints();
   JSONObject json = new JSONObject(jsonString);
   JSONObject mandatoryJSON = json.optJSONObject("mandatory");
   if (mandatoryJSON != null) {
     JSONArray mandatoryKeys = mandatoryJSON.names();
     if (mandatoryKeys != null) {
       for (int i = 0; i < mandatoryKeys.length(); ++i) {
         String key = mandatoryKeys.getString(i);
         String value = mandatoryJSON.getString(key);
         constraints.mandatory.add(new MediaConstraints.KeyValuePair(key, value));
       }
     }
   }
   JSONArray optionalJSON = json.optJSONArray("optional");
   if (optionalJSON != null) {
     for (int i = 0; i < optionalJSON.length(); ++i) {
       JSONObject keyValueDict = optionalJSON.getJSONObject(i);
       String key = keyValueDict.names().getString(0);
       String value = keyValueDict.getString(key);
       constraints.optional.add(new MediaConstraints.KeyValuePair(key, value));
     }
   }
   return constraints;
 }
  private void assertGroupByResults(JSONArray jsonArray, Map<Object, Double> groupResultsFromAvro)
      throws JSONException {
    final Map<String, Double> groupResultsFromQuery = new HashMap<String, Double>();
    if (groupResultsFromAvro.size() > 10) {
      Assert.assertEquals(jsonArray.length(), 10);
    } else {
      Assert.assertTrue(jsonArray.length() >= groupResultsFromAvro.size());
    }
    for (int i = 0; i < jsonArray.length(); ++i) {
      groupResultsFromQuery.put(
          jsonArray.getJSONObject(i).getJSONArray("group").getString(0),
          jsonArray.getJSONObject(i).getDouble("value"));
    }

    for (final Object key : groupResultsFromAvro.keySet()) {
      String keyString;
      if (key == null) {
        keyString = "null";
      } else {
        keyString = key.toString();
      }
      if (!groupResultsFromQuery.containsKey(keyString)) {
        continue;
      }
      final double actual = groupResultsFromQuery.get(keyString);
      // System.out.println("Result from query - group:" + keyString + ", value:" + actual);
      final double expected = groupResultsFromAvro.get(key);
      // System.out.println("Result from avro - group:" + keyString + ", value:" + expected);
      try {
        Assert.assertEquals(actual, expected);
      } catch (AssertionError e) {
        throw new AssertionError(e);
      }
    }
  }
 /**
  * Convert json payload to map.
  *
  * @param payloadsArray JSON Array containing payload details
  * @return map of payloads
  */
 private Map<Integer, Map<String, String>> getPayloadsAsMap(JSONArray payloadsArray) {
   Map<Integer, Map<String, String>> payloadsMap = new HashMap<Integer, Map<String, String>>();
   for (int i = 0; i < payloadsArray.length(); i++) {
     try {
       String payload =
           payloadsArray.getJSONObject(i).getString(AnalyticsConstants.JSON_FIELD_PAYLOAD);
       JSONArray eventRefs =
           payloadsArray.getJSONObject(i).getJSONArray(AnalyticsConstants.JSON_FIELD_EVENTS);
       for (int j = 0; j < eventRefs.length(); j++) {
         int eventIndex =
             eventRefs.getJSONObject(j).getInt(AnalyticsConstants.JSON_FIELD_EVENT_INDEX);
         Map<String, String> existingPayloadMap = payloadsMap.get(eventIndex);
         if (existingPayloadMap == null) {
           Map<String, String> attributesMap = new HashMap<String, String>();
           attributesMap.put(
               eventRefs.getJSONObject(j).getString(AnalyticsConstants.JSON_FIELD_ATTRIBUTE),
               payload);
           payloadsMap.put(eventIndex, attributesMap);
         } else {
           existingPayloadMap.put(
               eventRefs.getJSONObject(j).getString(AnalyticsConstants.JSON_FIELD_ATTRIBUTE),
               payload);
         }
       }
     } catch (JSONException e) {
       throw new RuntimeException(
           "Error occured while generating payload map: " + e.getMessage(), e);
     }
   }
   return payloadsMap;
 }
Beispiel #9
0
  public static Map<String, Object> getStringPlace(String json) {
    Map<String, Object> res = new HashMap<String, Object>();

    try {
      SubjectVo mSV = new SubjectVo();
      JSONObject objItem = new JSONObject(json);
      String subjectname = objItem.getString("subjectname");
      String subjectid = objItem.getString("subjectid");
      mSV.setSubjectId(subjectid);
      mSV.setSubjectName(subjectname);
      res.put("sv", mSV);
      String[] id = null;
      String[] name = null;
      JSONArray classList = objItem.getJSONArray("classlist");
      if (classList != null && classList.length() > 0) {
        id = new String[classList.length()];
        name = new String[classList.length()];
        for (int i = 0; i < classList.length(); i++) {
          JSONObject classItem = (JSONObject) classList.get(i);
          String classid = classItem.getString("classid");
          String schoollocation = classItem.getString("schoollocation");
          name[i] = schoollocation;
          id[i] = classid;
          LogUtil.d("&&&&&&&", schoollocation + "  classid : " + classid);
        }
        res.put("name", name);
        res.put("id", id);
      }

    } catch (Exception e) {
      e.printStackTrace();
    }

    return res;
  }
Beispiel #10
0
 /**
  * Converts a json array to a string array
  *
  * @param json
  * @return
  */
 public static String[] jsonArrayToString(JSONArray json) throws JSONException {
   String[] values = new String[json.length()];
   for (int i = 0; i < json.length(); i++) {
     values[i] = json.getString(i);
   }
   return values;
 }
  public static void fillSpinner() {
    try {
      json_klassen = new JSONArray(strklasse);
      int arraylengh = (json_klassen.length() - 1);
      klasse = new String[arraylengh][3];
      int k = 0;
      for (int j = 1; j < json_klassen.length(); j++) {
        JSONArray temp;
        temp = json_klassen.getJSONArray(j);

        if (j == 37) {
          System.out.println();
        }

        klasse[k][1] = temp.getString(0);
        klasse[k][0] = temp.getString(1);
        klasse[k][2] = temp.getString(2);

        k++;
      }

      arl_klassen.clear();
      for (int i = 0; i < klasse.length; i++) {
        arl_klassen.add(klasse[i][1]);
      }

    } catch (JSONException e) {
      e.printStackTrace();
    }
    adapterspinner.notifyDataSetChanged();
    spinner_klasse.setSelection(favorit);
  }
  private void parseItems(List<PhotographerPlace> items, JSONObject jsonBody)
      throws IOException, JSONException {
    JSONArray resultJsonArray = jsonBody.getJSONArray("results");

    for (int i = 0; i < resultJsonArray.length(); i++) {
      PhotographerPlace item = new PhotographerPlace();
      JSONObject resultJsonObject = resultJsonArray.getJSONObject(i);
      if (resultJsonObject.has("photos")) {
        JSONArray photoJsonArray = resultJsonObject.getJSONArray("photos");
        if (photoJsonArray.length() > 0) {
          for (int j = 0; j < photoJsonArray.length(); j++) {
            JSONObject photoJsonObject = photoJsonArray.getJSONObject(j);
            item.setIconURL(photoJsonObject.getString("photo_reference"));
          }
        }
      }
      item.setAddress(resultJsonObject.getString("formatted_address"));
      item.setName(resultJsonObject.getString("name"));
      item.setID(resultJsonObject.getString("place_id"));

      // item.setPriceLevel(resultJsonObject.getString("price_level"));
      // item.setRating(resultJsonObject.getString("rating"));
      items.add(item);
    }
  }
  public int populateTracks(int event_id, JITrackAdapter m_trackAdapter) {
    int trackCount = 0;
    Cursor c = this.db.rawQuery("SELECT json FROM events WHERE event_id = " + event_id, null);

    if (c.getCount() == 0) {
      c.close();
      return 0;
    }

    c.moveToFirst();
    try {
      JSONObject json = new JSONObject(c.getString(0));
      JSONArray json_tracks = json.getJSONArray("tracks");
      trackCount = json_tracks.length();

      for (int i = 0; i != json_tracks.length(); i++) {
        m_trackAdapter.add(json_tracks.getJSONObject(i));
      }
    } catch (JSONException e) {
      android.util.Log.e("JoindInApp", "Could not add item to list", e);
    }

    c.close();
    return trackCount;
  }
  private User[] parseJson(String json) {
    // TODO: put results into list and display it

    // System.out.print(json);

    User[] users = null;

    try {
      JSONArray jsonArr = new JSONArray(json);
      users = new User[jsonArr.length()];

      Random rand = new Random();
      for (int i = 0; i < jsonArr.length(); i++) {
        JSONObject obj = jsonArr.getJSONObject(i);
        User u =
            new User(
                obj.getInt("id"),
                obj.getJSONObject("user").getString("username"),
                String.valueOf(rand.nextInt((400 - 50) + 1) + 50),
                obj.getJSONObject("user").getString("number"),
                Float.parseFloat(obj.getJSONObject("user").getString("reputation")));
        users[i] = u;
        // System.out.print(u.toString());
      }
    } catch (JSONException e) {
      e.printStackTrace();
    }
    return users;
  }
Beispiel #15
0
  public static RepostList parse(String jsonString) {
    if (TextUtils.isEmpty(jsonString)) {
      return null;
    }

    RepostList reposts = new RepostList();
    try {
      JSONObject jsonObject = new JSONObject(jsonString);
      reposts.previous_cursor = jsonObject.optString("previous_cursor", "0");
      reposts.next_cursor = jsonObject.optString("next_cursor", "0");
      reposts.total_number = jsonObject.optInt("total_number", 0);

      JSONArray jsonArray = jsonObject.optJSONArray("reposts");
      if (jsonArray != null && jsonArray.length() > 0) {
        int length = jsonArray.length();
        reposts.repostsList = new ArrayList<Reposts>(length);
        for (int ix = 0; ix < length; ix++) {
          reposts.repostsList.add(Reposts.parse(jsonArray.getJSONObject(ix)));
        }
      }
    } catch (JSONException e) {
      e.printStackTrace();
    }

    return reposts;
  }
  private List<Place> retrievePlaces(String locationID, String type) throws IOException {

    StringBuilder urlBuilder = new StringBuilder(urlList);
    urlBuilder.append(locationID);
    urlBuilder.append("/");
    urlBuilder.append(type);
    urlBuilder.append("?lang=");
    urlBuilder.append(language);
    urlBuilder.append("&key=");
    urlBuilder.append(apiKey);

    String urlString = urlBuilder.toString();

    String genreJson = restProvider.retrieveRawInformation(urlString);
    JSONObject json = new JSONObject(genreJson);

    JSONArray data = json.getJSONArray("data");

    List<Place> result = new ArrayList<>(data.length());
    for (int i = 0; i < data.length(); i++) {

      Place place = buildPlace(data.getJSONObject(i));
      completePlace(place);
      result.add(place);
    }

    return result;
  }
  /** Unpacks the response from remote TF manager into this object. */
  @Override
  protected CommandResult unpackResponseFromJson(JSONObject json) throws JSONException {
    Status status = Status.NOT_ALLOCATED;
    FreeDeviceState state = FreeDeviceState.AVAILABLE;
    String statusString = json.getString(STATUS);
    try {
      status = CommandResult.Status.valueOf(statusString);
    } catch (IllegalArgumentException e) {
      throw new JSONException(String.format("unrecognized status '%s'", statusString));
    }

    String errorDetails = json.optString(INVOCATION_ERROR, null);
    String freeDeviceString = json.optString(FREE_DEVICE_STATE, null);
    if (freeDeviceString != null) {
      try {
        state = FreeDeviceState.valueOf(freeDeviceString);
      } catch (IllegalArgumentException e) {
        throw new JSONException(String.format("unrecognized state '%s'", freeDeviceString));
      }
    }

    Map<String, String> runMetricsMap = null;
    JSONArray jsonRunMetricsArray = json.optJSONArray(RUN_METRICS);
    if (jsonRunMetricsArray != null && jsonRunMetricsArray.length() > 0) {
      ImmutableMap.Builder<String, String> mapBuilder = new ImmutableMap.Builder<String, String>();
      for (int i = 0; i < jsonRunMetricsArray.length(); i++) {
        JSONObject runMetricJson = jsonRunMetricsArray.getJSONObject(i);
        final String key = runMetricJson.getString(RUN_METRICS_KEY);
        final String value = runMetricJson.getString(RUN_METRICS_VALUE);
        mapBuilder.put(key, value);
      }
      runMetricsMap = mapBuilder.build();
    }
    return new CommandResult(status, errorDetails, state, runMetricsMap);
  }
 @Override
 public void handleMessage(Message msg) {
   System.out.println("handler");
   if (msg.what == 0) {
     if (listaDeRemedios.size() > 0) listaDeRemedios.clear();
     if (jArray != null) {
       remedios = new Remedio[jArray.length()];
       for (int i = 0; i < jArray.length(); i++) {
         try {
           System.out.println("agregando..." + i);
           JSONObject json_data = jArray.getJSONObject(i);
           listaDeRemedios.add(new Remedios(json_data.getString("nombreReal"), "", 0));
         } catch (JSONException e) {
           e.printStackTrace();
         }
       }
       listaDeRemedios.add(new Remedios("Últimos Modificados :D", "", 0));
     }
     if (jArray2 != null) {
       for (int i = 0; i < jArray2.length(); i++) {
         try {
           System.out.println("agregando..." + i);
           JSONObject json_data2 = jArray2.getJSONObject(i);
           listaDeRemedios.add(new Remedios(json_data2.getString("nombreReal"), "", 0));
         } catch (JSONException e) {
           e.printStackTrace();
         }
       }
       // adapter.notifyDataSetChanged();
       // listaDeBusquedas.setAdapter(adapter);
     }
   }
   Tabs.mTitleProgressBar.setVisibility(ProgressBar.INVISIBLE);
 }
Beispiel #19
0
  public Map<String, List<JSONObject>> getAllCms() throws Exception {
    Map<String, List<JSONObject>> resultMap = new HashMap<String, List<JSONObject>>();
    int[] minMaxIds = getMinAndMaxIds();
    logger.debug("minMaxIds: " + Arrays.toString(minMaxIds));
    int length = 500;
    JSONArray cmsResultArray = null;
    for (int i = minMaxIds[0]; i < minMaxIds[1]; i += length) {
      cmsResultArray = loadCmsByPkCms(i, (i + length - 1), length);
      if (cmsResultArray != null) {
        for (int j = 0; j < cmsResultArray.length(); j++) {
          JSONObject cmsObj = cmsResultArray.getJSONObject(j);
          JSONArray cmsKeyword = cmsObj.optJSONArray("keywords");

          addJSONObjectToList(cmsObj.optString("title"), cmsObj, resultMap);
          if (cmsKeyword != null) {
            for (int k = 0; k < cmsKeyword.length(); k++) {
              addJSONObjectToList(cmsKeyword.optString(k), cmsObj, resultMap);
            }
          }
        }
      }
    }

    return resultMap;
  }
Beispiel #20
0
  /**
   * Constructs a Rate from a JSONObject.
   *
   * @param rateInformationJson The JSONObject holding the data to construct this object with.
   */
  public Rate(final JSONObject rateInformationJson) {

    final List<Room> localRooms;
    final JSONObject roomGroupJson = rateInformationJson.optJSONObject("RoomGroup");
    if (roomGroupJson != null && roomGroupJson.optJSONArray("Room") != null) {
      final JSONArray roomJson = roomGroupJson.optJSONArray("Room");
      localRooms = new ArrayList<Room>(roomJson.length());
      for (int i = 0; i < roomJson.length(); i++) {
        localRooms.add(new Room(roomJson.optJSONObject(i)));
      }
    } else if (roomGroupJson != null && roomGroupJson.optJSONObject("Room") != null) {
      localRooms = Collections.singletonList(new Room(roomGroupJson.optJSONObject("Room")));
    } else {
      localRooms = Collections.emptyList();
    }

    final JSONObject chargeableObject = rateInformationJson.optJSONObject("ChargeableRateInfo");
    final JSONObject convertedObject = rateInformationJson.optJSONObject("ConvertedRateInfo");

    chargeable = new RateInformation(chargeableObject);
    converted = convertedObject == null ? null : new RateInformation(convertedObject);

    promo = rateInformationJson.optBoolean("@promo");
    roomGroup = Collections.unmodifiableList(localRooms);
  }
  private String[] parseJSONData(String result) {
    String zipCodeArray[] = null;
    try {
      JSONObject jsonObj = new JSONObject(result);
      JSONArray arrayList = (JSONArray) jsonObj.get("postalCodes");
      zipCodeArray = new String[arrayList.length()];
      String zipCode = null;
      int iActualCount = 0;
      for (int iIndexCount = 0; iIndexCount <= arrayList.length(); ++iIndexCount) {
        try {
          zipCode = (String) ((JSONObject) arrayList.get(iIndexCount)).get("postalCode");
          zipCodeArray[iActualCount] = zipCode;
          ++iActualCount;

        } catch (org.json.JSONException e) {
          e.printStackTrace();
        }
      }

    } catch (org.json.JSONException e) {
      e.printStackTrace();
    }

    return zipCodeArray;
  }
Beispiel #22
0
 /**
  * Parses a list of Rate objects from a JSONArray representing their data.
  *
  * @param rateInformationsJson The json from which to parse
  * @return The Rate objects represented by the JSONArray.
  */
 public static List<Rate> parseRates(final JSONArray rateInformationsJson) {
   final List<Rate> rateInformations = new ArrayList<Rate>(rateInformationsJson.length());
   for (int j = 0; j < rateInformationsJson.length(); j++) {
     rateInformations.add(new Rate(rateInformationsJson.optJSONObject(j)));
   }
   return rateInformations;
 }
Beispiel #23
0
  @Override
  protected ArrayList<String> doInBackground(String... params) {

    ArrayList<String> resultList = null;
    String data;

    data = new AsyncronsTask().downloadData(params[0]);

    try {
      // Create a JSON object hierarchy from the results
      JSONObject jsonObj = new JSONObject(data);
      JSONArray predsJsonArray = jsonObj.getJSONArray("predictions");

      // Extract the Place descriptions from the results
      resultList = new ArrayList<String>(predsJsonArray.length());
      for (int i = 0; i < predsJsonArray.length(); i++) {
        resultList.add(predsJsonArray.getJSONObject(i).getString("description"));
      }
    } catch (JSONException e) {
      Log.e("LOG_TAG", "Cannot process JSON results", e);
    }

    Log.e("1", "" + resultList.toString());
    return resultList;
  }
  public String getPersonaggiStoriciJSON() {
    logger.info("ListaPersonaggi JSON");

    String res = "";

    Sparql sp = new Sparql(queryPersonaggiStorici, endpoint);
    JSONObject result = new JSONObject(sp.returnJSON());
    JSONArray jarray = result.getJSONObject("results").getJSONArray("bindings");
    JSONArray arrayRisultati = new JSONArray(); // riscrivamo i risultati in maniera piu bella
    for (int i = 0; i < jarray.length(); i++) {
      JSONObject row = new JSONObject();
      String uri = jarray.getJSONObject(i).getJSONObject("person").getString("value");
      String name = jarray.getJSONObject(i).getJSONObject("name").getString("value");
      String job = "";
      if (jarray.getJSONObject(i).has("job"))
        job = jarray.getJSONObject(i).getJSONObject("job").getString("value");
      row.accumulate("URI", uri);
      row.accumulate("name", name);
      row.accumulate("icona", Place.returnJobIcona(job));
      row.accumulate(
          "detailEndpoint",
          ServerTomcat
              + infoPersonaggio
              + uri.replace("http://www.trentinocultura.net/asp_cat/main.asp?", ""));
      arrayRisultati.put(row);
    }
    logger.info("Restituiti " + arrayRisultati.length() + " personaggi storici");

    // return sp.returnJSON();
    return arrayRisultati.toString();
  }
 private String[] readPlaybackSpeedArray(String valueFromPrefs) {
   String[] selectedSpeeds = null;
   // If this preference hasn't been set yet, return the default options
   if (valueFromPrefs == null) {
     String[] allSpeeds = context.getResources().getStringArray(R.array.playback_speed_values);
     List<String> speedList = new LinkedList<String>();
     for (String speedStr : allSpeeds) {
       float speed = Float.parseFloat(speedStr);
       if (speed < 2.0001 && speed * 10 % 1 == 0) {
         speedList.add(speedStr);
       }
     }
     selectedSpeeds = speedList.toArray(new String[speedList.size()]);
   } else {
     try {
       JSONArray jsonArray = new JSONArray(valueFromPrefs);
       selectedSpeeds = new String[jsonArray.length()];
       for (int i = 0; i < jsonArray.length(); i++) {
         selectedSpeeds[i] = jsonArray.getString(i);
       }
     } catch (JSONException e) {
       Log.e(TAG, "Got JSON error when trying to get speeds from JSONArray");
       e.printStackTrace();
     }
   }
   return selectedSpeeds;
 }
    @Override
    protected void onPostExecute(String s) {
      super.onPostExecute(s);
      Log.d("Spinner", "e onPostExecute---->" + s);
      try {
        JSONArray jsonArray = new JSONArray(s);
        reasonStrings = new String[jsonArray.length() + 1];
        idStrings = new String[jsonArray.length() + 1];

        for (int i = 0; i < jsonArray.length(); i++) {
          if (i == 0) {
            reasonStrings[i] = "--select reason--";
            idStrings[i] = "";
          } else {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            reasonStrings[i] = jsonObject.getString("res_name");
            idStrings[i] = jsonObject.getString("res_id");
          }
        }

        ArrayAdapter arrayAdapter =
            new ArrayAdapter(context, R.layout.support_simple_spinner_dropdown_item, reasonStrings);
        reason1Spinner.setAdapter(arrayAdapter);
        reason2Spinner.setAdapter(arrayAdapter);

      } catch (Exception e) {
        Log.d("Spinner", "e onPostExecute+++" + e.toString());
      }
    }
  public ArrayList<RecipeGeneral> getRecipesFromJSONString(String result2) {
    ArrayList<RecipeGeneral> recipes = new ArrayList<RecipeGeneral>();
    try {
      JSONArray jsonElements = new JSONArray(result2);
      Log.d(TAG, "In MainListActivity getRecipes(): " + jsonElements);
      Log.d(TAG, "jsonElements.length(): " + jsonElements.length());
      for (int i = 0; i < jsonElements.length(); i++) {
        Recipe favRecipe = (ModelUtil.getRecipeFromJSON(jsonElements.getJSONObject(i)));
        Log.d(TAG, "Recipe: " + jsonElements.getJSONObject(i));
        JSONArray stepsArray = jsonElements.getJSONObject(i).getJSONArray("steps");
        Log.d(TAG, "Steps: " + jsonElements.getJSONObject(i).getJSONArray("steps"));
        ArrayList<Step> favSteps = new ArrayList<Step>();

        for (int j = 0; j < stepsArray.length(); j++) {
          Step step = ModelUtil.getStepFromJSON(stepsArray.getJSONObject(j));
          Log.d(TAG, "Step: " + step);
          favSteps.add(step);
        }
        Log.d(TAG, "Steps ArrayList: " + favSteps);
        favRecipe.setSteps(favSteps);
        recipes.add((RecipeGeneral) favRecipe);
        Log.d(TAG, "In MainListActivity getRecipes() Adding every recipe");
      }
    } catch (Exception e) {
      e.printStackTrace();
      receiver.send(Constants.AUTHORIZATION_NOT_PASSED, null);
    }
    return recipes;
  }
Beispiel #28
0
  /**
   * @param jsonData is the total data sent by the OI Note
   * @return It return the array of RecievedData which contains localId and JSON string containing
   *     data like title etc.
   */
  private RecievedData[] getRecievedArray(String jsonData) {
    RecievedData[] rdArray = null;
    try {
      JSONObject jdataobj = new JSONObject(jsonData);
      JSONArray jsonArray = jdataobj.getJSONArray("data");
      rdArray = new RecievedData[jsonArray.length()];
      if (debug)
        Log.d(
            TAG, "length of rdArray and JsonArray: " + rdArray.length + " : " + jsonArray.length());
      for (int i = 0; i < jsonArray.length(); i++) {
        JSONObject jobj = jsonArray.getJSONObject(i);
        int localid = jobj.getInt("id");
        String jsonString = jobj.getString("jsonString");
        rdArray[i] = new RecievedData(localid, jsonString);
        if (debug)
          Log.d(
              TAG,
              "local id inside the RD object: "
                  + rdArray[i].getLocal_id()
                  + " "
                  + rdArray[i].getJsonString());
      }

    } catch (JSONException e) {
      if (debug) Log.d(TAG, "json exception occured", e);
    }
    return rdArray;
  }
 public void doAfterPostSuccess(String s, int articleId) {
   if (s.equals("IOException")) {
     Toast.makeText(
             getActivity().getApplicationContext(),
             "Server not available, please contact application owner",
             Toast.LENGTH_SHORT)
         .show();
     mAdapter.notifyDataSetChanged();
     swipeLayout.setRefreshing(false);
     return;
   }
   addNewArticleToUser(s, articleId);
   done++;
   Log.d("SVF", "Done " + done + " out of " + topics.length());
   if (done == topics.length()) {
     swipeLayout.setRefreshing(false);
     ValuesAndUtil.getInstance().saveUserData(user, getActivity().getApplicationContext());
     try {
       JSONArray sortedTopics =
           ValuesAndUtil.getInstance().sortTopicsArray(user.getJSONArray("topics"));
       user.put("topics", sortedTopics);
       ValuesAndUtil.getInstance().saveUserData(user, getActivity().getApplicationContext());
       mAdapter = new StoriesViewAdapter(sortedTopics);
       if (numUpdated == 0) {
         Toast.makeText(getActivity(), "No updates found for any stories", Toast.LENGTH_SHORT)
             .show();
       }
     } catch (JSONException e) {
       e.printStackTrace();
     }
     mRecyclerView.setAdapter(mAdapter);
     Log.d("SVF", "Finished updating all articles");
   }
 }
 private void parseCategories(JSONArray categoryRootArray) {
   categoriesConcatenated = "";
   for (int i = 0; i < categoryRootArray.length(); i++) {
     JSONObject jsoCategory;
     try {
       jsoCategory = categoryRootArray.getJSONObject(i);
       JSONArray jsaSubCategories = jsoCategory.optJSONArray("children");
       if (jsaSubCategories.length() > 0) {
         parseCategories(jsaSubCategories);
       } else // this category is a leaf
       {
         String leafCategoryKey = jsoCategory.optString("key");
         String leafCategoryName =
             MainActivity.translationManager.getTranslation(
                 TranslationManager.MAP_NAME_CATEGORIES, leafCategoryKey);
         categoryLeafNames.add(leafCategoryName);
       }
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
   boolean firstCategoryAdded = false;
   for (int i = 0; i < categoryLeafNames.size(); i++) {
     if (!firstCategoryAdded) {
       categoriesConcatenated = categoryLeafNames.get(i);
       firstCategoryAdded = true;
     } else categoriesConcatenated += ", " + categoryLeafNames.get(i);
   }
 }