Example #1
0
  private IGeometry decodeGeometry(JSONObject object) throws JSONException {
    IGeometry geom = null;
    LineString[] lineStrings;
    if (object.get("type").equals("MultiLineString")) {
      JSONArray coordinates = object.getJSONArray("coordinates");
      int size = coordinates.length();
      lineStrings = new LineString[size];
      LineString l;
      for (int i = 0; i < size; i++) {
        JSONArray lineStrCoord = coordinates.getJSONArray(i);
        double[][] coords = this.decodeLineStringCoords(lineStrCoord);
        l = new LineString(coords[0], coords[1]);
        lineStrings[i] = l;
      }

      geom = new MultiLineString(lineStrings);
    } else if (object.get("type").equals("LineString")) {
      JSONArray coordinates = object.getJSONArray("coordinates");
      double[][] coords = this.decodeLineStringCoords(coordinates);
      geom = new LineString(coords[0], coords[1]);
    } else if (object.get("type").equals("Point")) {
      JSONArray coordinates = object.getJSONArray("coordinates");
      geom = new Point(coordinates.getDouble(0), coordinates.getDouble(1));
    } else if (object.get("type").equals("Polygon")) {
      JSONArray coordinates = object.getJSONArray("coordinates");
      double[][] coords = this.decodeLineStringCoords(coordinates);
      geom = new Polygon(coords[0], coords[1]);
    }

    return geom;
  }
Example #2
0
  private ArrayList<LatLng> parseJsonLocation(JSONObject jsonLocation) {
    ArrayList<LatLng> points = new ArrayList<>();

    try {
      JSONObject json = jsonLocation;
      // JSONArray features = json.getJSONArray("features");
      // JSONObject feature = features.getJSONObject(0);
      JSONObject geometry = json.getJSONObject("geometry");

      if (geometry != null) {
        String type = geometry.getString("type");
        if (!TextUtils.isEmpty(type) && type.equalsIgnoreCase("LineString")) {
          JSONArray coords = geometry.getJSONArray("coordinates");
          for (int i = 0; i < coords.length(); i++) {
            JSONArray coord = coords.getJSONArray(i);
            LatLng latLng = new LatLng(coord.getDouble(0), coord.getDouble(1));
            points.add(latLng);
            Log.i(TAG, "아" + points.get(i).getLatitude() + " , " + points.get(i).getLongitude());
          }
        }
      }
    } catch (Exception e) {
      Log.e(TAG, "Excepting Parsing GeoJson: " + e.toString());
    }
    return points;
  }
Example #3
0
  public static Tweet parseTweet(JSONObject input) {
    // Example of a tweet in JSON format:
    // https://dev.twitter.com/docs/api/1/get/search
    // logger.info("parsing as twitter doc");
    try {
      Tweet t = new Tweet();

      JSONObject user;
      user = input.getJSONObject("user");
      t.userID = user.getLong("id");
      t.text = input.getString("text");
      t.isRetweet = !input.isNull("retweeted_status");
      t.setDoctype(DocumentType.TWIITER_DOC);
      if (input.has("coordinates") && !input.isNull("coordinates")) {
        JSONObject geo = (JSONObject) input.getJSONObject("coordinates");
        if (geo.getString("type") == "Point") {
          JSONArray coords = geo.getJSONArray("coordinates");
          GeoLabel.LonLatPair geotag = new GeoLabel.LonLatPair();
          geotag.setLongitude(coords.getDouble(0));
          geotag.setLatitude(coords.getDouble(1));
        }
      }
      return t;
    } catch (JSONException e) {
      logger.error("Json exception in parsing tweet: " + input);
      logger.error(elog.toStringException(e));
      throw new RuntimeException(e);
    }
  }
Example #4
0
 public List<Object> parseJSONArray(JSONArray values, Table table) throws ParseException {
   List<Object> parsedValues = new ArrayList<>();
   for (int i = 0; i < table.getColumnsCount(); i++) {
     Class<?> type = table.getColumnType(i);
     Object val = values.get(i);
     if (val.equals(null)) {
       parsedValues.add(null);
     } else if (type == Integer.class && val.getClass() == Integer.class) {
       parsedValues.add(values.getInt(i));
     } else if (type == Long.class
         && (val.getClass() == Long.class || val.getClass() == Integer.class)) {
       parsedValues.add(values.getLong(i));
     } else if (type == Byte.class && val.getClass() == Integer.class) {
       Integer a = values.getInt(i);
       parsedValues.add(a.byteValue());
     } else if (type == Float.class && val.getClass() == Double.class) {
       Double a = values.getDouble(i);
       parsedValues.add(a.floatValue());
     } else if (type == Double.class && val.getClass() == Double.class) {
       parsedValues.add(values.getDouble(i));
     } else if (type == Boolean.class && val.getClass() == Boolean.class) {
       parsedValues.add(values.getBoolean(i));
     } else if (type == String.class && val.getClass() == String.class) {
       parsedValues.add(val);
     } else {
       throw new ParseException("types mismatch", 0);
     }
   }
   return parsedValues;
 }
 /**
  * Creates a Fuzzy Set by parsing a JSON object.
  *
  * <p>{ "name" : String, "value" : [ [ Real, Real ], // X,Y ... ] }
  *
  * <p>Where name is the name of the Fuzzy Set, and value is a list of points that make up the set.
  *
  * @param object JSON object describing a fuzzy set
  */
 public FuzzySet(JSONObject object) {
   name = object.getString("name");
   values = new ArrayList<>();
   JSONArray valuesArray = object.getJSONArray("value");
   for (int i = 0; i < valuesArray.length(); ++i) {
     JSONArray point = valuesArray.getJSONArray(i);
     Pair pair = new Pair(point.getDouble(0), point.getDouble(1));
     addValue(pair);
   }
 }
Example #6
0
 public Position(JSONArray pos) {
   for (int i = 0; i < 2; i++) {
     try {
       if (i == 0) {
         this.x = pos.getDouble(i);
       } else if (i == 1) {
         this.y = pos.getDouble(i);
       }
     } catch (JSONException e) {
       System.err.println("[Building Tank Position] JSON Error");
     }
   }
 }
 /**
  * set width
  *
  * @param args
  * @param callbackContext
  * @throws JSONException
  */
 @SuppressWarnings("unused")
 private void setWidth(final JSONArray args, final CallbackContext callbackContext)
     throws JSONException {
   String id = args.getString(1);
   float width = (float) args.getDouble(2) * this.density;
   this.setFloat("setWidth", id, width, callbackContext);
 }
  private Marker processJSONObject(JSONObject jo) {
    if (jo == null) throw new NullPointerException();

    if (!jo.has("geometry")) throw new NullPointerException();

    Marker ma = null;
    try {
      Double lat = null, lon = null;

      if (!jo.isNull("geometry")) {
        JSONObject geo = jo.getJSONObject("geometry");
        JSONArray coordinates = geo.getJSONArray("coordinates");
        lon = coordinates.getDouble(0);
        lat = coordinates.getDouble(1);
      }
      if (lat != null) {
        String user = jo.getString("id");

        ma = new IconMarker(user, lat, lon, 0, Color.RED, icon);
      }
      Log.i("point", lon + ", " + lat + ": " + ma.getName());
    } catch (Exception e) {
      e.printStackTrace();
    }
    return ma;
  }
 /**
  * set z-index
  *
  * @param args
  * @param callbackContext
  * @throws JSONException
  */
 @SuppressWarnings("unused")
 private void setZIndex(final JSONArray args, final CallbackContext callbackContext)
     throws JSONException {
   String id = args.getString(1);
   float zIndex = (float) args.getDouble(2);
   this.setFloat("setZIndex", id, zIndex, callbackContext);
 }
Example #10
0
  private static List<?> getList(JSONArray jsonArray, Class<?> childrenType)
      throws JSONException, IllegalAccessException, InstantiationException {

    List<Object> list = new Vector<Object>(jsonArray.length());

    for (int i = 0; i < jsonArray.length(); i++) {

      Object child = null;

      if (childrenType == List.class) {
        child = getList(jsonArray.getJSONArray(i), childrenType);

      } else if (childrenType == String.class) {
        child = jsonArray.getString(i);

      } else if (childrenType == boolean.class || childrenType == Boolean.class) {
        child = jsonArray.getBoolean(i);

      } else if (childrenType == int.class || childrenType == Integer.class) {
        child = jsonArray.getInt(i);

      } else if (childrenType == double.class || childrenType == Double.class) {
        child = jsonArray.getDouble(i);

      } else {
        child = childrenType.newInstance();
        reflectJsonObject(child, jsonArray.getJSONObject(i));
      }

      list.add(child);
    }

    return list;
  }
  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;
  }
Example #12
0
    /*
    Parse the json file into list of GeoPoints
     */
    private List<GeoPoint> getGeoPoints(String json) {
      List<GeoPoint> geoPoints = new ArrayList<GeoPoint>();
      try {
        // get rid of renderAdvancedNarrative
        JSONObject obj =
            new JSONObject(json.replace("renderAdvancedNarrative(", "").replace(")", ""));
        JSONObject route = obj.getJSONObject("route");
        JSONObject shape = route.getJSONObject("shape");
        JSONArray shapePoints = shape.getJSONArray("shapePoints");

        // get each latlon pair and add to geopoint list
        for (int i = 0; i < shapePoints.length(); i = i + 2) {
          Double lat = shapePoints.getDouble(i);
          Double lng = shapePoints.getDouble(i + 1);
          geoPoints.add(new GeoPoint(lat, lng));
        }
      } catch (JSONException e) {
        e.printStackTrace();
      }
      return geoPoints;
    }
 public static float[] getFloatArray(SharedPreferences pref, String key) {
   float[] array = null;
   String s = pref.getString(key, null);
   if (s != null) {
     try {
       JSONArray json = new JSONArray(s);
       array = new float[json.length()];
       for (int i = 0; i < array.length; i++) array[i] = (float) json.getDouble(i);
     } catch (JSONException e) {
       e.printStackTrace();
     }
   }
   return array;
 }
  private void executeLogEvent(JSONArray args, CallbackContext callbackContext)
      throws JSONException {
    if (args.length() == 0) {
      // Not enough parameters
      callbackContext.error("Invalid arguments");
      return;
    }

    String eventName = args.getString(0);
    if (args.length() == 1) {
      logger.logEvent(eventName);
      callbackContext.success();
      return;
    }

    // Arguments is greater than 1
    JSONObject params = args.getJSONObject(1);
    Bundle parameters = new Bundle();
    Iterator<String> iter = params.keys();

    while (iter.hasNext()) {
      String key = iter.next();
      try {
        // Try get a String
        String value = params.getString(key);
        parameters.putString(key, value);
      } catch (JSONException e) {
        // Maybe it was an int
        Log.w(TAG, "Type in AppEvent parameters was not String for key: " + key);
        try {
          int value = params.getInt(key);
          parameters.putInt(key, value);
        } catch (JSONException e2) {
          // Nope
          Log.e(TAG, "Unsupported type in AppEvent parameters for key: " + key);
        }
      }
    }

    if (args.length() == 2) {
      logger.logEvent(eventName, parameters);
      callbackContext.success();
    }

    if (args.length() == 3) {
      double value = args.getDouble(2);
      logger.logEvent(eventName, value, parameters);
      callbackContext.success();
    }
  }
  private void deserializeFromObj(JSONObject obj) throws JSONException {
    this.TravelMode = obj.optString("travelMode");
    this.TravelDistance = obj.optDouble("travelDistance");
    this.TravelDuration = obj.optLong("travelDuration");

    JSONObject maneuverPoint = obj.getJSONObject("maneuverPoint");

    if (maneuverPoint != null) {
      JSONArray jsonArray = maneuverPoint.optJSONArray("coordinates");

      if (jsonArray != null && jsonArray.length() >= 2) {
        this.ManeuverPoint = new Coordinate(jsonArray.getDouble(0), jsonArray.getDouble(1));
      }
    }

    JSONObject instruction = obj.getJSONObject("instruction");
    this.Instruction = new Instruction(instruction);

    this.CompassDirection = obj.optString("compassDirection");

    JSONArray hints = obj.optJSONArray("hint");
    if (hints != null) {
      this.Hint = new Hint[hints.length()];
      for (int i = 0; i < hints.length(); i++) {
        this.Hint[i] = new Hint(hints.getJSONObject(i));
      }
    }

    JSONArray warnings = obj.optJSONArray("warning");
    if (warnings != null) {
      this.Warning = new Warning[warnings.length()];
      for (int i = 0; i < warnings.length(); i++) {
        this.Warning[i] = new Warning(warnings.getJSONObject(i));
      }
    }
  }
Example #16
0
  // Generate a bathroom object based on an incoming JSON file from server
  public void setDetails(JSONObject details) throws JSONException {
    JSONArray loc = details.getJSONArray("loc");
    mID = details.getInt("id");
    mLocation = new LatLng(loc.getDouble(0), loc.getDouble(1));
    mClass = details.getString("class");
    mGender = details.getString("gender");
    mNovelty = (float) details.getDouble("novelty");
    mCleanliness = (float) details.getDouble("cleanliness");
    mFloor = details.getInt("floor");
    mPrivate = details.getBoolean("public");
    mPaper = details.getBoolean("paper");
    mDryers = details.getBoolean("dryers");
    mStalls = details.getInt("stalls");
    mHandicap = details.getBoolean("handicap");
    mSinks = details.getInt("sinks");
    mSanitizer = details.getBoolean("sanitizer");
    mBaby = details.getBoolean("baby");
    mUrinals = details.getInt("urinals");
    mFeminine = details.getBoolean("feminine");
    mMedicine = details.getBoolean("medicine");
    mContraceptive = details.getBoolean("contraceptive");

    mComplete = true;
  }
 @Override
 public boolean execute(String action, JSONArray args, CallbackContext callbackContext)
     throws JSONException {
   try {
     if (action.equals("isScreenReaderRunning")) {
       isScreenReaderRunning(callbackContext);
       return true;
     } else if (action.equals("isClosedCaptioningEnabled")) {
       isClosedCaptioningEnabled(callbackContext);
       return true;
     } else if (action.equals("isTouchExplorationEnabled")) {
       isTouchExplorationEnabled(callbackContext);
       return true;
     } else if (action.equals("postNotification")) {
       if (args.length() > 1) {
         String string = args.getString(1);
         if (!string.isEmpty()) {
           announceForAccessibility(string, callbackContext);
         }
       }
       return true;
     } else if (action.equals("getTextZoom")) {
       getTextZoom(callbackContext);
       return true;
     } else if (action.equals("setTextZoom")) {
       if (args.length() > 0) {
         double textZoom = args.getDouble(0);
         if (textZoom > 0) {
           setTextZoom(textZoom, callbackContext);
         }
       }
       return true;
     } else if (action.equals("updateTextZoom")) {
       updateTextZoom(callbackContext);
       return true;
     } else if (action.equals("start")) {
       start(callbackContext);
       return true;
     } else if (action.equals("stop")) {
       stop();
       return true;
     }
   } catch (JSONException e) {
     e.printStackTrace();
     callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
   }
   return false;
 }
 public static float[] getFloatArray(SharedPreferences pref, String key) {
   float[] array = null;
   String s = pref.getString(key, null);
   if (s != null) {
     try {
       JSONArray json = new JSONArray(s);
       array = new float[json.length()];
       for (int i = 0; i < array.length; i++) {
         array[i] = (float) json.getDouble(i);
       }
     } catch (JSONException e) {
       Log.e(TAG, "getFloatArray: " + e.getClass() + ": " + e.getLocalizedMessage());
     }
   }
   return array;
 }
Example #19
0
  public static PredictionModel parseJSON(String jsonString) throws JSONException {
    PredictionModel result = new PredictionModel();

    JSONObject object = new JSONObject(jsonString);

    result.setAccuracy((float) object.getDouble("acc"));
    result.setMinRssi((float) object.getDouble("min_rssi"));
    result.setMaxRssi((float) object.getDouble("max_rssi"));

    JSONArray bArray = object.getJSONArray("b");
    float[] b = new float[bArray.length()];
    for (int i = 0; i < bArray.length(); ++i) {
      b[i] = (float) bArray.getDouble(i);
    }
    result.setB(b);

    JSONArray WArray = object.getJSONArray("W");
    int width = WArray.length();
    int height = WArray.getJSONArray(0).length();
    float[][] W = new float[height][width];
    for (int y = 0; y < height; ++y) {
      for (int x = 0; x < width; ++x) {
        W[y][x] = (float) WArray.getJSONArray(x).getDouble(y);
      }
    }
    result.setW(W);

    JSONObject roomsObject = object.getJSONObject("rooms");
    Iterator<String> roomKeys = roomsObject.keys();
    while (roomKeys.hasNext()) {
      String roomName = roomKeys.next();
      int roomIndex = roomsObject.getInt(roomName);
      result.getRooms().put(roomName, roomIndex);
    }

    JSONObject tagsObject = object.getJSONObject("tags");
    Iterator<String> tagKeys = tagsObject.keys();
    while (tagKeys.hasNext()) {
      String tagAddress = tagKeys.next();
      int tagIndex = tagsObject.getInt(tagAddress);
      result.getTags().put(tagAddress, tagIndex);
    }

    return result;
  }
Example #20
0
 // 构造函数
 public Line(JSONObject line) {
   try {
     lineName = line.getString("lineName");
     lineSummary = line.getString("lineSummary");
     coverThumbnail = line.getString("coverThumbnail");
     mapType = line.getString("mapType");
     mapAddress = line.getString("mapAddress");
     JSONArray locatArray = line.getJSONArray("locate");
     locate[0] = locatArray.getDouble(0);
     locate[0] = locatArray.getDouble(1);
     language = line.getString("language");
     lineLength = line.getString("lineLength");
     JSONArray topicsArray = line.getJSONArray("topics");
     for (int i = 0; i < topicsArray.length(); i++) {
       topics[i] = topicsArray.getString(i);
     }
     price = line.getString(price);
     author = line.getString(author);
     authorImage = line.getString("authorImage");
     authorEmail = line.getString("authorEmail");
     authorBio = line.getString("authorBio");
     authorType = line.getString("authorType");
     keyWords = new ArrayList<String>();
     traffics = line.getString("traffics");
     cautions = line.getString("cautions");
     lineLinks = line.getString("lineLinks");
     lineVedio = line.getString("lineVedio");
     totalPeople = (float) line.getDouble("totalPeople");
     totalScore = (float) line.getDouble("totalScore");
     JSONArray stopsArray = line.getJSONArray("stops");
     for (int i = 0; i < stopsArray.length(); i++) {
       stops.add(new Stop(stopsArray.getJSONObject(i)));
     }
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
 @Override
 public Vertex<LongWritable, VertexDataStructure, FloatWritable> getCurrentVertex()
     throws IOException, InterruptedException {
   Text line = getRecordReader().getCurrentValue();
   Vertex<LongWritable, VertexDataStructure, FloatWritable> vertex = getConf().createVertex();
   try {
     JSONArray jsonVertex = new JSONArray(line.toString());
     vertex.initialize(
         new LongWritable(jsonVertex.getLong(0)),
         new VertexDataStructure(jsonVertex.getLong(1), new HashSet<Long>()));
     JSONArray jsonEdgeArray = jsonVertex.getJSONArray(2);
     for (int i = 0; i < jsonEdgeArray.length(); ++i) {
       JSONArray jsonEdge = jsonEdgeArray.getJSONArray(i);
       Edge<LongWritable, FloatWritable> edge =
           EdgeFactory.create(
               new LongWritable(jsonEdge.getLong(0)),
               new FloatWritable((float) jsonEdge.getDouble(1)));
       vertex.addEdge(edge);
     }
   } catch (JSONException e) {
     throw new IllegalArgumentException("next: Couldn't get vertex from line " + line, e);
   }
   return vertex;
 }
Example #22
0
  private void DrawTransports(String jsonString, Boolean isCenter) {
    List<Overlay> mapOverlays = null;
    MapView mapView = (MapView) findViewById(R.id.mapview);
    JSONArray array = String2JsonArray(jsonString);
    if (array != null) {
      int minLatitude = Integer.MAX_VALUE, minLongitude = Integer.MAX_VALUE;
      int maxLatitude = Integer.MIN_VALUE, maxLongitude = Integer.MIN_VALUE;
      EditText et = (EditText) findViewById(R.id.editTextInfo);
      // TODO: Add show marshruts
      // et.setText(GetCurrentTime()+". "+String.valueOf(spyMarshrut)+"("+array.length()+")");
      Map<String, Integer> infoMap = new HashMap<String, Integer>();
      for (int n = 0; n < array.length(); n++) {
        try {
          JSONObject jo = array.getJSONObject(n);
          String info = jo.getString("info");
          String marshrutNumber = getTransportNumber(info);
          if (infoMap.containsKey(marshrutNumber)) {
            int oldValue = infoMap.get(marshrutNumber);
            oldValue++;
            infoMap.put(marshrutNumber, oldValue);
          } else {
            infoMap.put(marshrutNumber, 1);
          }

          JSONArray coordinatesJsonArray = jo.getJSONArray("cordinate");
          int iLatitude, iLongitude;
          if (coordinatesJsonArray.length() > 1) {
            iLatitude = (int) (coordinatesJsonArray.getDouble(0) * 1000000);
            minLatitude = Math.min(minLatitude, iLatitude);
            maxLatitude = Math.max(minLatitude, iLatitude);
            iLongitude = (int) (coordinatesJsonArray.getDouble(1) * 1000000);
            minLongitude = Math.min(minLongitude, iLongitude);
            maxLongitude = Math.max(minLongitude, iLongitude);
            String transportNumber = getTransportNumber(info);
            Drawable drawable;
            drawable = new TextDrawable(transportNumber);
            DrawableItemizedOverlay itemizedoverlay = new DrawableItemizedOverlay(drawable, this);
            GeoPoint point = new GeoPoint(iLatitude, iLongitude);
            OverlayItem overlayitem = new OverlayItem(point, "Info", info);
            itemizedoverlay.addOverlay(overlayitem);

            if (mapOverlays == null) {
              mapOverlays = mapView.getOverlays();
              mapOverlays.clear();
            }
            mapOverlays.add(itemizedoverlay);
          }
        } catch (JSONException e) {
          e.printStackTrace();
        }
      }
      String s = infoMap.toString();
      et.setText(GetCurrentTime() + ". " + s);
      if (isCenter && minLatitude != Integer.MAX_VALUE) {
        MapController mapController = mapView.getController();
        GeoPoint point =
            new GeoPoint((minLatitude + maxLatitude) / 2, (minLongitude + maxLongitude) / 2);
        mapController.animateTo(point);
      }
      mapView.invalidate();
    }
  }
  public void setParameters() {
    if (config == null) {
      read();
    }

    try {
      JSONArray distribution;
      minGoToWaitingRoom =
          new TimeSpan(config.getInt("go_to_waiting_room_min_time_span"), TimeUnit.MINUTES);
      maxGoToPlatform =
          new TimeSpan(config.getInt("go_to_platform_max_time_span"), TimeUnit.MINUTES);
      externalDelayInfoSpan =
          new TimeSpan(config.getInt("external_delay_info_time_span"), TimeUnit.MINUTES);

      minCompanionComingTime =
          new TimeSpan(config.getInt("min_companion_coming_time_span"), TimeUnit.MINUTES);
      maxCompanionComingTime =
          new TimeSpan(config.getInt("max_companion_coming_time_span"), TimeUnit.MINUTES);
      minComingTimeWithTicket =
          new TimeSpan(config.getInt("min_coming_time_span_with_ticket"), TimeUnit.MINUTES);
      maxComingTimeWithTicket =
          new TimeSpan(config.getInt("max_coming_time_span_with_ticket"), TimeUnit.MINUTES);
      minComingTimeWithoutTicket =
          new TimeSpan(config.getInt("min_coming_time_span_without_ticket"), TimeUnit.MINUTES);
      maxComingTimeWithoutTicket =
          new TimeSpan(config.getInt("max_coming_time_span_without_ticket"), TimeUnit.MINUTES);

      complainingProbability = config.getInt("average_probability_of_complaining") / 100.0;
      gettingInformationProbability =
          config.getInt("average_probability_of_getting_information") / 100.0;
      buyingTicketProbability = config.getInt("average_probability_of_buying_ticket") / 100.0;
      externalDelayProbability = config.getInt("average_probability_of_external_delay") / 100.0;

      distribution = config.getJSONArray("companion_count_distribution");
      companionCountDist = new double[distribution.length()];
      for (int i = 0; i < distribution.length(); i++) {
        companionCountDist[i] = Math.max(0, distribution.getDouble(i));
      }

      distribution = config.getJSONArray("visitor_coming_distribution");
      visitorComingDist = new int[distribution.length()];
      for (int i = 0; i < distribution.length(); i++) {
        visitorComingDist[i] = Math.max(distribution.getInt(i), 0);
      }

      platformCount = config.getInt("platform_count");
      infoDeskCount = config.getInt("info_desk_count");
      cashDeskCount = config.getInt("cash_desk_count");
      waitingRoomCapacity = config.getInt("waiting_room_capacity");

      minArrivingPassengerCount = config.getInt("min_arriving_passenger_count");
      maxArrivingPassengerCount = config.getInt("max_arriving_passenger_count");
      minDeparturingPassengerCount = config.getInt("min_departuring_passenger_count");
      maxDeparturingPassengerCount = config.getInt("max_departuring_passenger_count");

      internalArrivalDuration =
          new TimeSpan(config.getInt("internal_arrival_time"), TimeUnit.MINUTES);
      defaultPlatformWaitingTime =
          new TimeSpan(config.getInt("default_platform_waiting_time"), TimeUnit.MINUTES);
      minExternalDelay = new TimeSpan(config.getInt("min_external_delay"), TimeUnit.MINUTES);
      maxExternalDelay = new TimeSpan(config.getInt("max_external_delay"), TimeUnit.MINUTES);

      minSellingTicketTime =
          new TimeSpan(config.getInt("min_selling_ticket_time"), TimeUnit.MINUTES);
      maxSellingTicketTime =
          new TimeSpan(config.getInt("max_selling_ticket_time"), TimeUnit.MINUTES);
      minServingInformationTime =
          new TimeSpan(config.getInt("min_serving_information_time"), TimeUnit.MINUTES);
      maxServingInformationTime =
          new TimeSpan(config.getInt("max_serving_information_time"), TimeUnit.MINUTES);

      String schedulingAlgoName = config.getString("scheduling_algorithm");
      if (schedulingAlgoName.equals("wait")) {
        schedulingAlgorithm = new WaitSchedulingAlgorithm();
      } else if (schedulingAlgoName.equals("random")) {
        schedulingAlgorithm = new FirstFreeSchedulingAlgorithm();
      }
    } catch (JSONException ex) {
      System.err.println("error parsing json configuration");
    }
  }
Example #24
0
  /**
   * Load a terrain object from a JSON file
   *
   * @param mapFile
   * @return
   * @throws FileNotFoundException
   */
  public static Terrain load(File mapFile) throws FileNotFoundException {

    Reader in = new FileReader(mapFile);
    JSONTokener jtk = new JSONTokener(in);
    JSONObject jsonTerrain = new JSONObject(jtk);

    int width = jsonTerrain.getInt("width");
    int depth = jsonTerrain.getInt("depth");
    Terrain terrain = new Terrain(width, depth);

    JSONArray jsonSun = jsonTerrain.getJSONArray("sunlight");
    float dx = (float) jsonSun.getDouble(0);
    float dy = (float) jsonSun.getDouble(1);
    float dz = (float) jsonSun.getDouble(2);
    terrain.setSunlightDir(dx, dy, dz);

    JSONArray jsonAltitude = jsonTerrain.getJSONArray("altitude");
    for (int i = 0; i < jsonAltitude.length(); i++) {
      int x = i % width;
      int z = i / width;

      double h = jsonAltitude.getDouble(i);
      terrain.setGridAltitude(x, z, h);
    }

    if (jsonTerrain.has("trees")) {
      JSONArray jsonTrees = jsonTerrain.getJSONArray("trees");
      for (int i = 0; i < jsonTrees.length(); i++) {
        JSONObject jsonTree = jsonTrees.getJSONObject(i);
        double x = jsonTree.getDouble("x");
        double z = jsonTree.getDouble("z");
        terrain.addTree(x, z);
      }
    }

    if (jsonTerrain.has("others")) {
      JSONArray jsonTrees = jsonTerrain.getJSONArray("others");
      for (int i = 0; i < jsonTrees.length(); i++) {
        JSONObject jsonTree = jsonTrees.getJSONObject(i);
        double x = jsonTree.getDouble("x");
        double z = jsonTree.getDouble("z");
        terrain.addOther(x, z);
      }
    }

    if (jsonTerrain.has("roads")) {
      JSONArray jsonRoads = jsonTerrain.getJSONArray("roads");
      for (int i = 0; i < jsonRoads.length(); i++) {
        JSONObject jsonRoad = jsonRoads.getJSONObject(i);
        double w = jsonRoad.getDouble("width");

        JSONArray jsonSpine = jsonRoad.getJSONArray("spine");
        double[] spine = new double[jsonSpine.length()];

        for (int j = 0; j < jsonSpine.length(); j++) {
          spine[j] = jsonSpine.getDouble(j);
        }
        terrain.addRoad(w, spine);
      }
    }
    return terrain;
  }
 @Override
 public boolean execute(String action, JSONArray args, CallbackContext callbackContext)
     throws JSONException {
   if (START_TRACKER.equals(action)) {
     String id = args.getString(0);
     this.startTracker(id, callbackContext);
     return true;
   } else if (TRACK_VIEW.equals(action)) {
     String screen = args.getString(0);
     this.trackView(screen, callbackContext);
     return true;
   } else if (TRACK_EVENT.equals(action)) {
     int length = args.length();
     if (length > 0) {
       this.trackEvent(
           args.getString(0),
           length > 1 ? args.getString(1) : "",
           length > 2 ? args.getString(2) : "",
           length > 3 ? args.getLong(3) : 0,
           callbackContext);
     }
     return true;
   } else if (TRACK_EXCEPTION.equals(action)) {
     String description = args.getString(0);
     Boolean fatal = args.getBoolean(1);
     this.trackException(description, fatal, callbackContext);
     return true;
   } else if (TRACK_TIMING.equals(action)) {
     int length = args.length();
     if (length > 0) {
       this.trackTiming(
           args.getString(0),
           length > 1 ? args.getLong(1) : 0,
           length > 2 ? args.getString(2) : "",
           length > 3 ? args.getString(3) : "",
           callbackContext);
     }
     return true;
   } else if (ADD_DIMENSION.equals(action)) {
     Integer key = args.getInt(0);
     String value = args.getString(1);
     this.addCustomDimension(key, value, callbackContext);
     return true;
   } else if (ADD_TRANSACTION.equals(action)) {
     int length = args.length();
     if (length > 0) {
       this.addTransaction(
           args.getString(0),
           length > 1 ? args.getString(1) : "",
           length > 2 ? args.getDouble(2) : 0,
           length > 3 ? args.getDouble(3) : 0,
           length > 4 ? args.getDouble(4) : 0,
           length > 5 ? args.getString(5) : null,
           callbackContext);
     }
     return true;
   } else if (ADD_TRANSACTION_ITEM.equals(action)) {
     int length = args.length();
     if (length > 0) {
       this.addTransactionItem(
           args.getString(0),
           length > 1 ? args.getString(1) : "",
           length > 2 ? args.getString(2) : "",
           length > 3 ? args.getString(3) : "",
           length > 4 ? args.getDouble(4) : 0,
           length > 5 ? args.getLong(5) : 0,
           length > 6 ? args.getString(6) : null,
           callbackContext);
     }
     return true;
   } else if (SET_USER_ID.equals(action)) {
     String userId = args.getString(0);
     this.setUserId(userId, callbackContext);
   } else if (DEBUG_MODE.equals(action)) {
     this.debugMode(callbackContext);
   } else if (ENABLE_UNCAUGHT_EXCEPTION_REPORTING.equals(action)) {
     Boolean enable = args.getBoolean(0);
     this.enableUncaughtExceptionReporting(enable, callbackContext);
   } else if (ENABLE_ADVERTISING_ID_COLLECTION.equals(action)) {
     this.enableAdvertisingIdCollection(callbackContext);
   }
   return false;
 }
Example #26
0
    /**
     * Get rows results from query cursor.
     *
     * @param cur Cursor into query results
     * @return results in string form
     */
    private JSONObject executeSqlStatementNDK(
        String query, JSONArray paramsAsJson, CallbackContext cbc) throws Exception {
      JSONObject rowsResult = new JSONObject();

      boolean hasRows = false;

      SQLiteStatement myStatement = mydb.prepareStatement(query);

      try {
        String[] params = null;

        params = new String[paramsAsJson.length()];

        for (int i = 0; i < paramsAsJson.length(); ++i) {
          if (paramsAsJson.isNull(i)) {
            myStatement.bindNull(i + 1);
          } else {
            Object p = paramsAsJson.get(i);
            if (p instanceof Float || p instanceof Double)
              myStatement.bindDouble(i + 1, paramsAsJson.getDouble(i));
            else if (p instanceof Number) myStatement.bindLong(i + 1, paramsAsJson.getLong(i));
            else myStatement.bindTextNativeString(i + 1, paramsAsJson.getString(i));
          }
        }

        hasRows = myStatement.step();
      } catch (Exception ex) {
        ex.printStackTrace();
        String errorMessage = ex.getMessage();
        Log.v("executeSqlBatch", "SQLitePlugin.executeSql[Batch](): Error=" + errorMessage);

        // cleanup statement and throw the exception:
        myStatement.dispose();
        throw ex;
      }

      // If query result has rows
      if (hasRows) {
        JSONArray rowsArrayResult = new JSONArray();
        String key = "";
        int colCount = myStatement.getColumnCount();

        // Build up JSON result object for each row
        do {
          JSONObject row = new JSONObject();
          try {
            for (int i = 0; i < colCount; ++i) {
              key = myStatement.getColumnName(i);

              switch (myStatement.getColumnType(i)) {
                case SQLColumnType.NULL:
                  row.put(key, JSONObject.NULL);
                  break;

                case SQLColumnType.REAL:
                  row.put(key, myStatement.getColumnDouble(i));
                  break;

                case SQLColumnType.INTEGER:
                  row.put(key, myStatement.getColumnLong(i));
                  break;

                case SQLColumnType.BLOB:
                case SQLColumnType.TEXT:
                default: // (just in case)
                  row.put(key, myStatement.getColumnTextNativeString(i));
              }
            }

            rowsArrayResult.put(row);

          } catch (JSONException e) {
            e.printStackTrace();
          }
        } while (myStatement.step());

        try {
          rowsResult.put("rows", rowsArrayResult);
        } catch (JSONException e) {
          e.printStackTrace();
        }
      }

      myStatement.dispose();

      return rowsResult;
    }
Example #27
0
  public static Depth formatJsonOfMarketDepth(MarketType marketType, JSONObject json)
      throws JSONException {
    Depth depth = new Depth();

    double rate = ExchangeUtil.getRate(marketType);
    int bidMaxPrice = 0;
    int askMinPrice = Integer.MAX_VALUE;

    List<DateValueEntity> bidDateValueEntities = new ArrayList<DateValueEntity>();
    List<DateValueEntity> askDateValueEntities = new ArrayList<DateValueEntity>();
    double bidSumVolume = 0;
    int splitIndex = 0;
    if (!json.isNull(BIDS)) {
      JSONArray bidArray = json.getJSONArray(BIDS);

      for (int i = bidArray.length() - 1; i >= 0; i--) {
        JSONArray bid = bidArray.getJSONArray(i);
        int bidPrice = bid.getInt(0);
        double price = ((double) bidPrice) / 100 * rate;
        double volume = bid.getDouble(1) / Math.pow(10, 8);
        if (bidMaxPrice < bidPrice) {
          bidMaxPrice = bidPrice;
        }
        bidSumVolume = bidSumVolume + volume;
        DateValueEntity dateValueEntity =
            new DateValueEntity(
                (float) bidSumVolume, StringUtil.formatDoubleToMoneyString(price), bidPrice);
        bidDateValueEntities.add(dateValueEntity);
      }
      splitIndex = bidArray.length();
    }
    double askSumVolume = 0;
    if (!json.isNull(ASKS)) {
      JSONArray askArray = json.getJSONArray(ASKS);

      for (int i = 0; i < askArray.length(); i++) {
        JSONArray ask = askArray.getJSONArray(i);
        int askPrice = ask.getInt(0);
        double price = ((double) askPrice) / 100 * rate;
        double volume = ask.getDouble(1) / Math.pow(10, 8);
        askSumVolume = askSumVolume + volume;
        if (askPrice < askMinPrice) {
          askMinPrice = askPrice;
        }
        DateValueEntity dateValueEntity =
            new DateValueEntity(
                (float) askSumVolume, StringUtil.formatDoubleToMoneyString(price), askPrice);
        askDateValueEntities.add(dateValueEntity);
      }
    }
    int mixPrice = (askMinPrice + bidMaxPrice) / 2;
    DateValueEntity zeroDateValue =
        new DateValueEntity(
            0, StringUtil.formatDoubleToMoneyString(((double) mixPrice) / 100 * rate), mixPrice);
    List<DateValueEntity> dateValueEntities = new ArrayList<DateValueEntity>();
    dateValueEntities.addAll(bidDateValueEntities);
    dateValueEntities.add(zeroDateValue);
    dateValueEntities.addAll(askDateValueEntities);
    Collections.sort(dateValueEntities, new ComparatorDateValue());
    depth.setMaxVolume(Math.max(askSumVolume, bidSumVolume));
    depth.setDateValueEntities(dateValueEntities);
    depth.setSplitIndex(splitIndex);
    return depth;
  }
    @Override
    public ContentValues fromJSON(Context context, Uri localItem, JSONObject item, String lProp)
        throws JSONException, NetworkProtocolException, IOException {
      final ContentValues cv = new ContentValues();

      switch (getType()) {
        case SyncFieldMap.STRING:
          cv.put(lProp, item.getString(remoteKey));
          break;

        case SyncFieldMap.INTEGER:
          cv.put(lProp, item.getInt(remoteKey));
          break;

        case SyncFieldMap.DOUBLE:
          cv.put(lProp, item.getDouble(remoteKey));
          break;

        case SyncFieldMap.BOOLEAN:
          cv.put(lProp, item.getBoolean(remoteKey));
          break;

        case SyncFieldMap.LIST_INTEGER:
        case SyncFieldMap.LIST_STRING:
        case SyncFieldMap.LIST_DOUBLE:
          {
            final JSONArray ar = item.getJSONArray(remoteKey);
            final List<String> l = new Vector<String>(ar.length());
            for (int i = 0; i < ar.length(); i++) {
              switch (getType()) {
                case SyncFieldMap.LIST_STRING:
                  l.add(ar.getString(i));
                  break;

                case SyncFieldMap.LIST_DOUBLE:
                  l.add(String.valueOf(ar.getDouble(i)));
                  break;

                case SyncFieldMap.LIST_INTEGER:
                  l.add(String.valueOf(ar.getInt(i)));
                  break;
              }
            }
            cv.put(lProp, TextUtils.join(LIST_DELIM, l));
          }
          break;

        case SyncFieldMap.DATE:
          try {
            cv.put(lProp, NetworkClient.parseDate(item.getString(remoteKey)).getTime());
          } catch (final ParseException e) {
            final NetworkProtocolException ne = new NetworkProtocolException("bad date format");
            ne.initCause(e);
            throw ne;
          }
          break;

        case SyncFieldMap.DURATION:
          {
            final Matcher m = durationPattern.matcher(item.getString(remoteKey));
            if (!m.matches()) {
              throw new NetworkProtocolException("bad duration format");
            }
            final int durationSeconds =
                1200 * Integer.parseInt(m.group(1))
                    + 60 * Integer.parseInt(m.group(2))
                    + Integer.parseInt(m.group(3));
            cv.put(lProp, durationSeconds);
          }
          break;
      }
      return cv;
    }
  public int loadStream() throws YAPI_Exception {
    JSONArray coldiv = null;
    int coltyp[] = null;
    double colscl[];
    int colofs[];

    JSONObject jsonObj = null;

    try {
      JSONTokener jsonTokenner = _dataLogger.getData(_runNo, _timeStamp);
      jsonObj = new JSONObject(jsonTokenner);
      if (jsonObj.has("time")) {
        _timeStamp = jsonObj.getInt("time");
      }
      if (jsonObj.has("UTC")) {
        _utcStamp = jsonObj.getLong("UTC");
      }
      if (jsonObj.has("interval")) {
        _interval = jsonObj.getInt("interval");
      }
      if (jsonObj.has("nRows")) {
        _nRows = jsonObj.getInt("nRows");
      }
      if (jsonObj.has("keys")) {
        JSONArray jsonKeys = jsonObj.getJSONArray("keys");
        if (_nCols == 0) {
          _nCols = jsonKeys.length();
        } else if (_nCols != jsonKeys.length()) {
          _nCols = 0;
          throw new YAPI_Exception(YAPI.IO_ERROR, "DataStream corrupted");
        }
        _columnNames = new ArrayList<String>(_nCols);
        for (int i = 0; i < jsonKeys.length(); i++) {
          _columnNames.add(jsonKeys.getString(i));
        }
      }

      if (jsonObj.has("div")) {
        coldiv = jsonObj.getJSONArray("div");
        if (_nCols == 0) {
          _nCols = coldiv.length();
        } else if (_nCols != coldiv.length()) {
          _nCols = 0;
          throw new YAPI_Exception(YAPI.IO_ERROR, "DataStream corrupted");
        }
      }

      if (jsonObj.has("type")) {
        JSONArray types = jsonObj.getJSONArray("type");
        if (_nCols == 0) {
          _nCols = types.length();
        } else if (_nCols != types.length()) {
          _nCols = 0;
          throw new YAPI_Exception(YAPI.IO_ERROR, "DataStream corrupted");
        }
        coltyp = new int[_nCols];
        for (int c = 0; c < _nCols; c++) {
          coltyp[c] = types.getInt(c);
        }
      }

      if (jsonObj.has("scal")) {

        JSONArray json_colscl = jsonObj.getJSONArray("scal");
        if (_nCols == 0) {
          _nCols = json_colscl.length();
        } else if (_nCols != json_colscl.length()) {
          _nCols = 0;
          throw new YAPI_Exception(YAPI.IO_ERROR, "DataStream corrupted");
        }
        colscl = new double[json_colscl.length()];
        colofs = new int[json_colscl.length()];
        for (int i = 0; i < json_colscl.length(); i++) {
          double dval = json_colscl.getDouble(i);
          colscl[i] = dval / 65536.0;
          colofs[i] = (coltyp[i] != 0 ? -32767 : 0);
        }
      } else {
        colscl = new double[coldiv.length()];
        colofs = new int[coldiv.length()];
        for (int i = 0; i < coldiv.length(); i++) {
          colscl[i] = 1.0 / coldiv.getDouble(i);
          colofs[i] = (coltyp[i] != 0 ? -32767 : 0);
        }
      }
    } catch (JSONException ex) {
      throw new YAPI_Exception(YAPI.IO_ERROR, "json parse error");
    }

    if (jsonObj != null && jsonObj.has("data")) {
      if (_nCols == 0 || coldiv == null || coltyp == null) {
        throw new YAPI_Exception(YAPI.IO_ERROR, "DataStream corrupted");
      }
      ArrayList<Integer> udata = null;
      try {
        String data = jsonObj.getString("data");
        udata = YAPI._decodeWords(data);
      } catch (JSONException ignore) {
      }

      if (udata == null) {
        try {
          JSONArray jsonData = jsonObj.getJSONArray("data");
          udata = new ArrayList<Integer>();
          for (int i = 0; i < jsonData.length(); i++) {
            udata.add(jsonData.getInt(i));
          }
        } catch (JSONException ex) {
          throw new YAPI_Exception(YAPI.IO_ERROR, "");
        }
      }
      _values = new ArrayList<ArrayList<Double>>();
      ArrayList<Double> dat = new ArrayList<Double>();
      int c = 0;
      for (int val_i : udata) {
        double val_d;
        if (coltyp[c] < 2) {
          val_d = (val_i + colofs[c]) * colscl[c];
        } else {
          val_d = YAPI._decimalToDouble(val_i - 32767);
        }
        dat.add(val_d);
        c++;
        if (c == _nCols) {
          _values.add(dat);
          dat = new ArrayList<Double>();
          c = 0;
        }
      }
    }
    return YAPI.SUCCESS;
  }
  private void deserializeKey(String key, Bundle bundle) throws JSONException {
    String jsonString = cache.getString(key, "{}");
    JSONObject json = new JSONObject(jsonString);

    String valueType = json.getString(JSON_VALUE_TYPE);

    if (valueType.equals(TYPE_BOOLEAN)) {
      bundle.putBoolean(key, json.getBoolean(JSON_VALUE));
    } else if (valueType.equals(TYPE_BOOLEAN_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      boolean[] array = new boolean[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = jsonArray.getBoolean(i);
      }
      bundle.putBooleanArray(key, array);
    } else if (valueType.equals(TYPE_BYTE)) {
      bundle.putByte(key, (byte) json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_BYTE_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      byte[] array = new byte[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = (byte) jsonArray.getInt(i);
      }
      bundle.putByteArray(key, array);
    } else if (valueType.equals(TYPE_SHORT)) {
      bundle.putShort(key, (short) json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_SHORT_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      short[] array = new short[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = (short) jsonArray.getInt(i);
      }
      bundle.putShortArray(key, array);
    } else if (valueType.equals(TYPE_INTEGER)) {
      bundle.putInt(key, json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_INTEGER_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      int[] array = new int[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = jsonArray.getInt(i);
      }
      bundle.putIntArray(key, array);
    } else if (valueType.equals(TYPE_LONG)) {
      bundle.putLong(key, json.getLong(JSON_VALUE));
    } else if (valueType.equals(TYPE_LONG_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      long[] array = new long[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = jsonArray.getLong(i);
      }
      bundle.putLongArray(key, array);
    } else if (valueType.equals(TYPE_FLOAT)) {
      bundle.putFloat(key, (float) json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_FLOAT_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      float[] array = new float[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = (float) jsonArray.getDouble(i);
      }
      bundle.putFloatArray(key, array);
    } else if (valueType.equals(TYPE_DOUBLE)) {
      bundle.putDouble(key, json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_DOUBLE_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      double[] array = new double[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        array[i] = jsonArray.getDouble(i);
      }
      bundle.putDoubleArray(key, array);
    } else if (valueType.equals(TYPE_CHAR)) {
      String charString = json.getString(JSON_VALUE);
      if (charString != null && charString.length() == 1) {
        bundle.putChar(key, charString.charAt(0));
      }
    } else if (valueType.equals(TYPE_CHAR_ARRAY)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      char[] array = new char[jsonArray.length()];
      for (int i = 0; i < array.length; i++) {
        String charString = jsonArray.getString(i);
        if (charString != null && charString.length() == 1) {
          array[i] = charString.charAt(0);
        }
      }
      bundle.putCharArray(key, array);
    } else if (valueType.equals(TYPE_STRING)) {
      bundle.putString(key, json.getString(JSON_VALUE));
    } else if (valueType.equals(TYPE_STRING_LIST)) {
      JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
      int numStrings = jsonArray.length();
      ArrayList<String> stringList = new ArrayList<String>(numStrings);
      for (int i = 0; i < numStrings; i++) {
        Object jsonStringValue = jsonArray.get(i);
        stringList.add(i, jsonStringValue == JSONObject.NULL ? null : (String) jsonStringValue);
      }
      bundle.putStringArrayList(key, stringList);
    } else if (valueType.equals(TYPE_ENUM)) {
      try {
        String enumType = json.getString(JSON_VALUE_ENUM_TYPE);
        @SuppressWarnings({"unchecked", "rawtypes"})
        Class<? extends Enum> enumClass = (Class<? extends Enum>) Class.forName(enumType);
        @SuppressWarnings("unchecked")
        Enum<?> enumValue = Enum.valueOf(enumClass, json.getString(JSON_VALUE));
        bundle.putSerializable(key, enumValue);
      } catch (ClassNotFoundException e) {
      } catch (IllegalArgumentException e) {
      }
    }
  }