Java Examples for org.json.JSONObject

public void testEscapeSlash() {
    JSONObject json = new JSONObject();
    try {
        json.put("key", "value");
    } catch (JSONException e) {
        e.printStackTrace();
    }
    String str = JsonEscapeUtil.escapeSlash(json);
    // expect : "{\"key\":\"value\"}"
    assertTrue(str.equals("\"{\\\"key\\\":\\\"value\\\"}\""));
}

public static String getJsonStringFromMap(final Map<String, Object> map) {
    String result = null;
    if (map != null && !map.isEmpty()) {
        try {
            JSONObject json = new JSONObject(map);
            result = json.toString();
        } catch (Exception e) {
            LogUtil.e(TAG, "getJsonStringFromMap exception =" + e.getMessage());
        }
    }
    return result;
}

/**
     * get Long from jsonData
     * 
     * @param jsonData
     * @param key
     * @param defaultValue
     * @return <ul>
     *         <li>if jsonObject is null, return defaultValue</li>
     *         <li>if jsonData {@link org.json.JSONObject#JSONObject(String)} exception, return defaultValue</li>
     *         <li>return {@link cn.trinea.android.common.util.JSONUtils#getLong(org.json.JSONObject, String, org.json.JSONObject)}</li>
     *         </ul>
     */
public static Long getLong(String jsonData, String key, Long defaultValue) {
    if (StringUtils.isEmpty(jsonData)) {
        return defaultValue;
    }
    try {
        JSONObject jsonObject = new JSONObject(jsonData);
        return getLong(jsonObject, key, defaultValue);
    } catch (JSONException e) {
        if (isPrintException) {
            e.printStackTrace();
        }
        return defaultValue;
    }
}

/**
     * Convert to Jettison JSONObject
     * @param source
     * @return
     */
public static JSONObject toJettison(Object source) {
    JSONObject json = null;
    if (source instanceof JSONObject) {
        json = (JSONObject) source;
    } else if (source instanceof org.json.JSONObject || source instanceof String) {
        json = stringToJettision(source.toString());
    } else if (source instanceof JsonNode) {
        json = stringToJettision(JacksonHelper.toString((JsonNode) source));
    } else if (source instanceof JsonParser) {
        json = stringToJettision(JacksonHelper.toString((JsonParser) source));
    }
    return json;
}

static ResponseList<Location> createLocationList(JSONArray paramJSONArray, boolean paramBoolean) throws TwitterException {
    for (; ; ) {
        int j;
        try {
            int i = paramJSONArray.length();
            ResponseListImpl localResponseListImpl = new ResponseListImpl(i, null);
            j = 0;
            if (j < i) {
                JSONObject localJSONObject = paramJSONArray.getJSONObject(j);
                LocationJSONImpl localLocationJSONImpl = new LocationJSONImpl(localJSONObject);
                localResponseListImpl.add(localLocationJSONImpl);
                if (paramBoolean) {
                    DataObjectFactoryUtil.registerJSONObject(localLocationJSONImpl, localJSONObject);
                }
            } else {
                if (paramBoolean) {
                    DataObjectFactoryUtil.registerJSONObject(localResponseListImpl, paramJSONArray);
                }
                return localResponseListImpl;
            }
        } catch (JSONException localJSONException) {
            throw new TwitterException(localJSONException);
        } catch (TwitterException localTwitterException) {
            throw localTwitterException;
        }
        j++;
    }
}

@Test
public void testToJson() throws JSONException {
    Action action = ActionParser.getAction("PLANE");
    Assert.assertNotNull(action);
    JSONObject jsonObject = action.toJson();
    Assert.assertEquals("SYSTEM", jsonObject.getString("category"));
    Assert.assertEquals("PLANE", jsonObject.getString("name"));
    JSONAssert.assertEquals("[{\"name\":\"status\",\"value\":false,\"type\":\"ON_OFF\"}]", jsonObject.getJSONArray("arguments").toString(), false);
}

public static int getHttpManagerPort() {
    File configFile = new File("/data/data/fq.router2/etc/fqsocks.json");
    if (!configFile.exists()) {
        return 2515;
    }
    try {
        return new JSONObject(IOUtils.readFromFile(configFile)).getJSONObject("http_manager").getInt("port");
    } catch (Exception e) {
        LogUtils.e("failed to parse config", e);
        return 2515;
    }
}

public static TelemetryItem createTelemetryItem(DocumentType docType, JSONObject json) throws Exception {
    switch(docType) {
        case Requests:
            return new RequestTelemetryItem(json);
        case PerformanceCounters:
            return new PerformanceCounterTelemetryItem(json);
        case Event:
            return new EventTelemetryItem(json);
        default:
            throw new Exception("Unsupported document type: " + docType.toString());
    }
}

public void testSaneValues() throws JSONException, IOException {
    Configuration config = new Configuration("some-api-key");
    DeviceState deviceState = new DeviceState(getContext());
    JSONObject deviceStateJson = streamableToJson(deviceState);
    assertTrue(deviceStateJson.getLong("freeMemory") > 0);
    assertNotNull(deviceStateJson.get("orientation"));
    assertTrue(deviceStateJson.getDouble("batteryLevel") > 0);
    assertTrue(deviceStateJson.getBoolean("charging"));
    assertEquals("allowed", deviceStateJson.getString("locationStatus"));
    assertNotNull(deviceStateJson.get("networkAccess"));
    assertNotNull(deviceStateJson.get("time"));
}

@Override
public void process(JSONObject content, JSONObject rawRequest, Server server) {
    JSONObject user = content.getJSONObject("user");
    JSONArray rolesArray = content.getJSONArray("roles");
    GroupUser gUser = server.getGroupUserById(user.getString("id"));
    ((UserImpl) gUser.getUser()).setUsername(user.getString("username"));
    ((UserImpl) gUser.getUser()).setAvatarId(user.getString("avatar"));
    ((UserImpl) gUser.getUser()).setAvatar("https://cdn.discordapp.com/avatars/" + api.getSelfInfo().getId() + "/" + (user.isNull("avatar") ? "" : user.getString("avatar")) + ".jpg");
    for (int i = 0; i < rolesArray.length(); i++) {
        JSONObject roleObj = rolesArray.getJSONObject(i);
        gUser.setRole(roleObj.getString("name"));
    }
}

public static int getHttpManagerPort() {
    File configFile = new File("/data/data/fq.router2/etc/fqsocks.json");
    if (!configFile.exists()) {
        return 2515;
    }
    try {
        return new JSONObject(IOUtils.readFromFile(configFile)).getJSONObject("http_manager").getInt("port");
    } catch (Exception e) {
        LogUtils.e("failed to parse config", e);
        return 2515;
    }
}

@Override
public void handler(String data, CallBackFunction function) {
    LogUtils.i(TAG, "receive data" + data);
    if (function != null) {
        JSONObject jsonObject = new JSONObject();
        try {
            jsonObject.put("data", "DefaultHandler response data");
        } catch (JSONException e) {
            e.printStackTrace();
        }
        function.onCallBack(jsonObject);
    }
}

public int parse() {
    try {
        JSONObject jsonObject = new JSONObject(data);
        String state = jsonObject.getString("state");
        if ("y".equalsIgnoreCase(state)) {
            return 0;
        } else {
            int code = jsonObject.getInt("code");
            return code;
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return -1;
}

@Override
public void execute(JSONObject response) {
    try {
        JSONObject body = new JSONObject(response.getString("body"));
        if ((response.getInt("statusCode") == 200 && body.getJSONObject("meta").getBoolean("status") != true) || (response.getInt("statusCode") != 200 && body.getJSONObject("meta").getBoolean("status") != false)) {
            System.out.println("Error in your code.");
        }
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

public static JSONObject encode(String data) {
    JSONObject output = new JSONObject();
    try {
        output.put(NetworkUtils.UID, NetworkUtils.genUniqueID());
        output.put(NetworkUtils.PROTOCOL, NetworkUtils.PROTOCOL_RAISE_HAND);
        output.put(NetworkUtils.DATA, data);
    } catch (JSONException e) {
        return null;
    }
    return output;
}

public void copyFrom(JSONObject jsonTrustLine) {
    otherAccount = jsonTrustLine.getString("account");
    balance = jsonTrustLine.getString("balance");
    currency = jsonTrustLine.getString("currency");
    limit = jsonTrustLine.getString("limit");
    limit_peer = jsonTrustLine.getString("limit_peer");
    quality_in = jsonTrustLine.getLong("quality_in");
    quality_out = jsonTrustLine.getLong("quality_out");
}

public static void main(String[] args) {
    String access_token = args[0];
    Trend tm = new Trend(access_token);
    int trendId = Integer.parseInt(args[1]);
    try {
        JSONObject result = tm.trendsDestroy(trendId);
        Log.logInfo(String.valueOf(result));
    } catch (WeiboException e) {
        e.printStackTrace();
    }
}

@SuppressWarnings("rawtypes")
public static Map toMap(JSONObject jsonObject) throws JSONException {
    HashMap<String, Object> hashMap = new HashMap<String, Object>();
    for (Iterator iterator = jsonObject.keys(); iterator.hasNext(); ) {
        String key = (String) iterator.next();
        Object obj = jsonObject.get(key);
        if (obj.getClass().getName().equalsIgnoreCase("org.json.JSONObject")) {
            Map map = toMap((JSONObject) obj);
            hashMap.put(key, map);
        } else if (obj.getClass().getName().equalsIgnoreCase("org.json.JSONArray")) {
            ArrayList<Object> arraylist = new ArrayList<Object>();
            JSONArray jsonArray = (JSONArray) obj;
            int index = 0;
            int length = jsonArray.length();
            while (index < length) {
                Object element = jsonArray.get(index);
                if (element instanceof JSONObject) {
                    Map tempMap = toMap((JSONObject) element);
                    arraylist.add(tempMap);
                } else {
                    arraylist.add(element);
                }
                index++;
            }
            hashMap.put(key, arraylist);
        } else {
            hashMap.put(key, obj);
        }
    }
    return hashMap;
}

public static String getDeviceInfo(Context context) {
    try {
        org.json.JSONObject json = new org.json.JSONObject();
        android.telephony.TelephonyManager tm = (android.telephony.TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String device_id = tm.getDeviceId();
        android.net.wifi.WifiManager wifi = (android.net.wifi.WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        String mac = wifi.getConnectionInfo().getMacAddress();
        json.put("mac", mac);
        if (TextUtils.isEmpty(device_id)) {
            device_id = mac;
        }
        if (TextUtils.isEmpty(device_id)) {
            device_id = android.provider.Settings.Secure.getString(context.getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
        }
        json.put("device_id", device_id);
        return json.toString();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public UploadedSoundDetails map(final JSONObject source) {
    final UploadedSoundDetails uploadedSoundDetails = new UploadedSoundDetails();
    uploadedSoundDetails.setDetail(extractFieldValue(source, "detail", String.class));
    uploadedSoundDetails.setId(extractFieldValue(source, "id", Integer.class));
    uploadedSoundDetails.setFilename(extractFieldValue(source, "filename", String.class));
    return uploadedSoundDetails;
}

public static String getDeviceInfo(Context context) {
    try {
        org.json.JSONObject json = new org.json.JSONObject();
        android.telephony.TelephonyManager tm = (android.telephony.TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String device_id = tm.getDeviceId();
        android.net.wifi.WifiManager wifi = (android.net.wifi.WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        String mac = wifi.getConnectionInfo().getMacAddress();
        json.put("mac", mac);
        if (TextUtils.isEmpty(device_id)) {
            device_id = mac;
        }
        if (TextUtils.isEmpty(device_id)) {
            device_id = android.provider.Settings.Secure.getString(context.getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
        }
        json.put("device_id", device_id);
        return json.toString();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static String getDeviceInfo(Context context) {
    try {
        org.json.JSONObject json = new org.json.JSONObject();
        android.telephony.TelephonyManager tm = (android.telephony.TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String device_id = tm.getDeviceId();
        android.net.wifi.WifiManager wifi = (android.net.wifi.WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        String mac = wifi.getConnectionInfo().getMacAddress();
        json.put("mac", mac);
        if (TextUtils.isEmpty(device_id)) {
            device_id = mac;
        }
        if (TextUtils.isEmpty(device_id)) {
            device_id = android.provider.Settings.Secure.getString(context.getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
        }
        json.put("device_id", device_id);
        return json.toString();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static String getDeviceInfo(Context context) {
    try {
        org.json.JSONObject json = new org.json.JSONObject();
        android.telephony.TelephonyManager tm = (android.telephony.TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String device_id = tm.getDeviceId();
        android.net.wifi.WifiManager wifi = (android.net.wifi.WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        String mac = wifi.getConnectionInfo().getMacAddress();
        json.put("mac", mac);
        if (TextUtils.isEmpty(device_id)) {
            device_id = mac;
        }
        if (TextUtils.isEmpty(device_id)) {
            device_id = android.provider.Settings.Secure.getString(context.getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
        }
        json.put("device_id", device_id);
        return json.toString();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public Book parse(JSONObject jsonBookObject) throws JSONException, IOException {
    Book book = new Book();
    book.setTitle(jsonBookObject.getJSONObject("title").getString("$t"));
    parseLinkJson(jsonBookObject, book);
    book.setAverageRate(jsonBookObject.getJSONObject("gd:rating").getString("@average"));
    parseMetadataJson(jsonBookObject, book);
    try {
        JSONObject summary = jsonBookObject.getJSONObject("summary");
        if (summary != null) {
            book.setSummary(summary.getString("$t"));
        }
    } catch (JSONException e) {
        System.out.println("eat this exception because in list screen, there is no summary info");
    }
    return book;
}

@Override
public Object getProperty() {
    JSONObject jsonObject = new JSONObject();
    for (String key : keys) {
        try {
            String deviceFolder = "/sys/devices/virtual/android_usb/android0/";
            String value = readFile(new File(deviceFolder, key));
            jsonObject.put(key, value.trim());
        } catch (Exception e) {
            try {
                jsonObject.put(key, JSONObject.NULL);
            } catch (JSONException e1) {
            }
        }
    }
    return jsonObject;
}

public void parseJson(JSONObject jsonobject, Map map) {
    String as[] = getArgs();
    int i;
    i = as.length;
    try {
        for (int j = 0; j < i; j++) {
            String s = as[j];
            Object obj = jsonobject.get(s);
            Object obj1 = map.put(s, obj);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public String transform(String json) {
    String ROOT = null;
    JSONObject jsonObject = null;
    if (//$NON-NLS-1$
    json.trim().startsWith("{")) {
        jsonObject = new JSONObject(json);
        if (jsonObject.length() > 1) {
            //$NON-NLS-1$
            ROOT = "root";
        }
    } else {
        JSONArray jsonArray = new JSONArray(json);
        jsonObject = new JSONObject().put(ELEMENT, jsonArray);
        //$NON-NLS-1$
        ROOT = "root";
    }
    return XML.toString(jsonObject, ROOT);
}

@Override
public ArrayList<T> newArray(JSONArray jArray) {
    // TODO Auto-generated method stub
    if (jArray == null) {
        return null;
    }
    ArrayList<T> list = new ArrayList<T>();
    int length = jArray.length();
    for (int i = 0; i < length; i++) {
        JSONObject jObj = jArray.optJSONObject(i);
        if (jObj == null) {
            continue;
        }
        T t = createFromJson(jObj);
        if (t == null) {
            continue;
        }
        list.add(t);
    }
    return list;
}

public JSONObject getConfig() {
    if (curConfig == null) {
        try {
            // If there's no pref set, just give back the empty JSON Object
            curConfig = new JSONObject(Prefs.getRemoteConfigJson());
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
    }
    return curConfig;
}

public JSONObject json() {
    JSONObject ret = new JSONObject();
    try {
        ret.put("ratio", ratio);
        ret.put("ratioLimit", ratioLimit);
        ret.put("pastSensitivity", pastSensitivity);
        ret.put("sensResult", sensResult);
        ret.put("ratio", ratio);
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return ret;
}

@Override
public PointF valueFromObject(Object object, float scale) {
    if (object instanceof JSONArray) {
        return JsonUtils.pointFromJsonArray((JSONArray) object, scale);
    } else if (object instanceof JSONObject) {
        return JsonUtils.pointFromJsonObject((JSONObject) object, scale);
    } else {
        throw new IllegalArgumentException("Unable to parse point from " + object);
    }
}

private boolean isProcessDeployed(String key) {
    String checkDeploymentUrl = Flowable5220Engine.URL + "/service/repository/deployments?name=" + key + ".bpmn";
    JSONObject result = JsonHelper.get(checkDeploymentUrl, 200);
    try {
        return result.getInt("size") == 1;
    } catch (JSONException e) {
        throw new RuntimeException(e);
    }
}

public LoginResult Convert(JSONObject userItem) {
    LoginResult result = new LoginResult();
    try {
        result.Result = userItem.getBoolean("result");
        result.IsBanned = userItem.getBoolean("isbanned");
        result.User = new User();
        result.User.Id = userItem.getString("_id");
        result.User.email = userItem.getString("useremail");
        result.User.Name = userItem.getString("username");
        NativeLogin login = new NativeLogin();
        login.PasswordHash = userItem.getString("password");
        login.Initialize(result.User);
        result.User.Login = login;
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return result;
}

@Override
public WalkRoom parse(JSONObject json) throws JSONException {
    WalkRoom obj = new WalkRoom();
    if (json.has("user")) {
        obj.setHandle(json.getString("user"));
    }
    if (json.has("sid")) {
        obj.setServerId(json.getInt("sid"));
    }
    if (json.has("cid")) {
        obj.setDataId(json.getInt("cid"));
    }
    if (json.has("x")) {
        obj.setSyncState(json.getInt("x"));
    }
    if (json.has("t")) {
        obj.setRoomName(json.getString("t"));
    }
    if (json.has("l")) {
        obj.setLastMsgTime(json.getString("l"));
    }
    return obj;
}

public static ReviewsObject GetReveiws(int id, int start) {
    //        String apiKey= LoginActivity.apiKey.toString();
    //        String apiKey="0dad551ec0f84ed02907ff5c42e8ec70";
    String url = ApiUrlHelper.USER_BOOK_REVIEWS.replace(":id", Integer.toString(id));
    if (start != 0) {
        url = url.replace("&count=30", "&start=" + start + "&count=30");
    }
    String json = JavaHttpClient.getInstance().doGet(url, null, null);
    try {
        ReviewsObject reviewsObject = ReviewsObject.parseJson(new JSONObject(json));
        return reviewsObject;
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return null;
}

public static List<String> getAliasesFromJson(String indexName, String jsonString) {
    List<String> retValue = new ArrayList<>();
    try {
        JSONObject json = new JSONObject(jsonString);
        JSONObject index = json.getJSONObject(indexName);
        JSONObject aliases = index.getJSONObject("aliases");
        for (Iterator iterator = aliases.keys(); iterator.hasNext(); ) {
            String key = (String) iterator.next();
            retValue.add(key);
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return retValue;
}

public Map<String, View> buildViews(JSONDocument doc) throws ViewException {
    JSONObject viewDefs = doc.getMetaData().getJSONObject("view");
    Map<String, View> views = new HashMap<String, View>();
    for (String k : viewDefs.keySet()) {
        String src = viewDefs.getString(k);
        views.put(src, new JavaScriptView(doc.getDatabase(), src));
    }
    return views;
}

public static String translateByBaiduAPI(String h1) {
    MyHttpClient myHttpClient = new MyHttpClient();
    String getrest = MyApplication.BAIDUTRANSLATEAPI + "q=" + h1 + "&from=auto&to=auto";
    try {
        String ret = myHttpClient.executeGetRequest(getrest);
        if (ret != null) {
            JSONObject jsonObject = new JSONObject(ret);
            JSONArray jsonArray = jsonObject.getJSONArray("trans_result");
            return jsonArray.getJSONObject(0).getString("dst");
        } else {
            return h1;
        }
    } catch (Exception e) {
        L.e(e.getMessage());
        return h1;
    }
}

@Override
public Todo parse(JSONObject json) throws JSONException {
    Todo obj = new Todo();
    if (json.has("created")) {
        obj.setCreated(json.getString("created"));
    }
    if (json.has("tip")) {
        obj.setTip(new TipParser().parse(json.getJSONObject("tip")));
    }
    if (json.has("todoid")) {
        obj.setId(json.getString("todoid"));
    }
    return obj;
}

public static String createCommentString(JSONObject json, List<String> filedList) {
    StringBuilder sb = new StringBuilder();
    sb.append("/** \n");
    for (int i = 0; i < filedList.size(); i++) {
        String key = filedList.get(i);
        sb.append("* ").append(key).append(" : ");
        sb.append(json.get(key).toString().replaceAll("\r", "").replaceAll("\t ", "").replaceAll("\f", ""));
        sb.append("\n");
    }
    sb.append("*/ \n");
    return sb.toString();
}

public static HokoException serverException(JSONObject errorJSON) {
    try {
        if (errorJSON.has("warning")) {
            return new ServerWarningException(errorJSON.getInt("status"), errorJSON.getString("warning"));
        } else if (errorJSON.has("error")) {
            return new ServerErrorException(errorJSON.getInt("status"), errorJSON.getString("error"));
        } else {
            return new GenericServerException();
        }
    } catch (JSONException jsonException) {
        return new GenericServerException();
    }
}

@Override
public void paser(JSONObject json) throws Exception {
    json = json.optJSONObject("result");
    preview = json.optString("preview");
    homeEntity = new TeamLineupEntity();
    awayEntity = new TeamLineupEntity();
    JSONObject homeObj = json.optJSONObject("home_roster");
    JSONObject awayObj = json.optJSONObject("away_roster");
    homeEntity.paser(homeObj);
    awayEntity.paser(awayObj);
}

public void parseJson() {
    try {
        JSONObject object = (JSONObject) new JSONTokener(json).nextValue();
        String query = object.getString("query");
        System.out.println("query: " + query);
        JSONArray locations = object.getJSONArray("locations");
        System.out.println("locations: " + locations);
        for (int i = 0; i < locations.length(); i++) {
            int location = locations.getInt(i);
            System.out.println("location: " + location);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public void reportSuccess(JSONObject obj) {
    try {
        JanusMessageType type = JanusMessageType.fromString(obj.getString("janus"));
        if (type != JanusMessageType.success) {
            callbacks.onCallbackError(obj.getJSONObject("error").getString("reason"));
        } else {
            callbacks.onSessionCreationSuccess((obj));
        }
    } catch (JSONException ex) {
        callbacks.onCallbackError(ex.getMessage());
    }
}

public static View build(View view, final JSONObject component, final JSONObject parent, Context context) {
    if (view == null) {
        return new View(context);
    } else {
        try {
            JasonComponent.build(view, component, parent, context);
            view.requestLayout();
            return view;
        } catch (Exception e) {
            Log.d("Error", e.toString());
            return new View(context);
        }
    }
}

@Override
public GraphObject deserializeObject(JSONObject data) {
    MessageThread messageThread = new MessageThread();
    deserializePrimitives(messageThread, data);
    messageThread.setRecipients(deserializeStringList(getJsonArray(data, "recipients")));
    messageThread.setRecipients_friends(new FriendDeserializer().deserializeArray(getJsonArray(data, "recipients_friends"), Friend.class));
    return messageThread;
}

@Override
public GraphObject deserializeObject(JSONObject data) {
    MessageThread messageThread = new MessageThread();
    deserializePrimitives(messageThread, data);
    messageThread.setRecipients(deserializeStringList(getJsonArray(data, "recipients")));
    messageThread.setRecipients_friends(new FriendDeserializer().deserializeArray(getJsonArray(data, "recipients_friends"), Friend.class));
    return messageThread;
}

@Override
public CommentSubmitFeedbackResult parse(JSONObject json) throws JSONException {
    CommentSubmitFeedbackResult comment_submit_feedbackResultType = new CommentSubmitFeedbackResult();
    if (json.has("errorCode")) {
        comment_submit_feedbackResultType.mErrorCode = json.getInt("errorCode");
    }
    if (json.has("type")) {
        comment_submit_feedbackResultType.mType = json.getString("type");
    }
    return comment_submit_feedbackResultType;
}

public static ArrayList<LQInAppMessage> parse(JSONArray array) {
    ArrayList<LQInAppMessage> list = new ArrayList<>();
    int length = array.length();
    for (int i = 0; i < length; ++i) {
        try {
            JSONObject inapp = array.getJSONObject(i);
            list.add(new LQInAppMessage(inapp));
        } catch (JSONException e) {
            LQLog.error("Error parsing inapp message " + array);
        }
    }
    return list;
}

@Override
public PointF valueFromObject(Object object, float scale) {
    if (object instanceof JSONArray) {
        return JsonUtils.pointFromJsonArray((JSONArray) object, scale);
    } else if (object instanceof JSONObject) {
        return JsonUtils.pointFromJsonObject((JSONObject) object, scale);
    } else {
        throw new IllegalArgumentException("Unable to parse point from " + object);
    }
}

public static JSONObject getAsJSON(Metadata metadata) {
    JSONObject json = new JSONObject();
    for (Directory directory : metadata.getDirectories()) {
        if (directory != null) {
            JSONObject directoryJSON = new JSONObject();
            for (Tag tag : directory.getTags()) {
                if (tag != null) {
                    directoryJSON.accumulate(tag.getTagName(), tag.getDescription());
                }
            }
            String directoryName = directory.getName();
            json.accumulate(directoryName, directoryJSON);
        }
    }
    return json;
}

public boolean parse(byte[] bytData) {
    try {
        reset();
        if (bytData == null || bytData.length <= 0)
            return false;
        String strData = new String(bytData, "UTF-8");
        System.out.println(strData);
        JSONObject json = new JSONObject(strData);
        m_nRetCode = json.optInt("retcode");
        json = json.optJSONObject("result");
        m_nResult = json.optInt("result");
        return true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

//parsing functions
@Override
public NewsImageRepresentation parseObject(JSONObject obj) {
    NewsImageRepresentation ir = null;
    try {
        ir = new NewsImageRepresentation();
        ir.setWidth(obj.getInt("width"));
        ir.setHeight(obj.getInt("height"));
        ir.setUrl(obj.getString("url"));
    } catch (JSONException e) {
        e.printStackTrace();
        ir = null;
    }
    return ir;
}

public void testResponse() throws JSONException {
    JSONObject json = JSONUtils.getJson(getInstrumentation().getContext(), R.raw.json_photos_get);
    PhotosResponse response = new PhotosResponse(json);
    assertNotNull(response);
    assertEquals(2, response.getTotalRows());
    assertNotNull(response.getPhotos());
    assertEquals(2, response.getPhotos().size());
    assertEquals("hl", response.getPhotos().get(0).getId());
    assertEquals("ob", response.getPhotos().get(1).getId());
}

@Override
public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
    if (action.equals("getRuntimeConfiguration")) {
        JSONObject resultJson = new JSONObject();
        resultJson.put("deviceId", MonacaDevice.getDeviceId(cordova.getActivity()));
        callbackContext.success(resultJson);
        return true;
    }
    // invalid action
    return false;
}

public static JSONObject addErrorFlag(String message, JSONObject object) {
    if (object == null) {
        object = new JSONObject();
    }
    try {
        if (!object.has("error"))
            object.put("error", "600");
        if (!object.has("message"))
            object.put("message", message);
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return object;
}

public static void main(String[] args) {
    String host = "127.0.0.1";
    int port = 8877;
    // 10 seconds
    long timeout = 10000;
    ProcBridge pb = new ProcBridge(host, port, timeout);
    try {
        JSONObject resp;
        resp = pb.request("echo", "{}");
        System.out.println(resp);
        resp = pb.request("add", "{elements: [1, 2, 3, 4, 5]}");
        System.out.println(resp);
    } catch (ProcBridgeException e) {
        e.printStackTrace();
    }
}

public Object decodeEntity(HttpEntity httpentity) throws JSONException {
    JSONObject jsonobject = null;
    String jsonString;
    if (httpentity == null) {
        return null;
    }
    try {
        jsonString = EntityUtils.toString(httpentity).trim();
    } catch (Exception e) {
        Log.e("JsonObjectEntityDecoder", "decodeEntity", e);
        return null;
    }
    if (!jsonString.isEmpty()) {
        jsonobject = new JSONObject(jsonString);
    }
    return jsonobject;
}

public JSONObject toJson() throws IOException {
    JSONObject jsonResult = null;
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    if (bufferedReader != null) {
        String resultStr = "";
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            resultStr += line;
        }
        bufferedReader.close();
        System.out.println("        JSON response: '" + resultStr + "'");
        jsonResult = new JSONObject(resultStr);
    }
    return jsonResult;
}

public static PacketTypes identifyPacket(JSONObject message) {
    try {
        if (message.getString("type").equals("register_device")) {
            return PacketTypes.REGISTER_DEVICE;
        } else if (message.getString("type").equals("register_view")) {
            return PacketTypes.REGISTER_VIEWS;
        } else {
            return PacketTypes.UNKNOWN;
        }
    } catch (JSONException e) {
    }
    return PacketTypes.UNKNOWN;
}

/**
	 * this method does not wait for response!
	 */
@Override
protected JSONObject doJSONRequest(JSONObject request) throws JSONRPCException {
    try {
        String data = request.toString();
        socket.sendData(data.getBytes());
        JSONObject result = new JSONObject();
        JSONObject resultOK = new JSONObject();
        resultOK.put("result", "OK");
        result.put(JSONRPCConstants.RESULT_KEY, resultOK);
        return result;
    } catch (Exception e) {
        throw new JSONRPCException(e.getMessage());
    }
}

public static void main(String[] args) {
    // convert Java to json
    JSONObject root = new JSONObject();
    root.put("message", "Hi");
    JSONObject place = new JSONObject();
    place.put("name", "World!");
    root.put("place", place);
    String json = root.toString();
    System.out.println(json);
    System.out.println();
    // convert json to Java
    JSONObject jsonObject = new JSONObject(json);
    String message = jsonObject.getString("message");
    String name = jsonObject.getJSONObject("place").getString("name");
    System.out.println(message + " " + name);
}

public static ReaderSimplePostList fromJsonPosts(@NonNull JSONArray jsonPosts) {
    ReaderSimplePostList posts = new ReaderSimplePostList();
    for (int i = 0; i < jsonPosts.length(); i++) {
        JSONObject jsonRelatedPost = jsonPosts.optJSONObject(i);
        if (jsonRelatedPost != null) {
            ReaderSimplePost relatedPost = ReaderSimplePost.fromJson(jsonRelatedPost);
            if (relatedPost != null) {
                posts.add(relatedPost);
            }
        }
    }
    return posts;
}

@SuppressWarnings({ "ThrowableResultOfMethodCallIgnored" })
@Test
public void testFromJSON() throws JSONException {
    String json = "{\n" + "  \"err\": {\n" + "    \"msg\": \"Data not found\",\n" + "    \"code\": 2\n" + "  },\n" + "  \"stat\": \"fail\"\n" + "}";
    RPXException ex = RPXException.fromJSON(new JSONObject(json));
    assertEquals("Data not found", ex.getMessage());
    assertEquals(2, ex.getCode());
    assertEquals(RPXStat.FAIL, ex.getStat());
}

/**
   * Converts the original JSON object from the wrapped JSON parser into
   * a {@link JSONValue} object.
   *
   * @param object  original JSON object from wrapped JSON parser
   * @return  {@code JSONValue} object
   */
static ServerJsonValue convert(Object object) {
    if (object == null || object == org.json.JSONObject.NULL) {
        return null;
    } else if (object instanceof Boolean) {
        return new ServerJsonBoolean((Boolean) object);
    } else if (object instanceof Number) {
        return new ServerJsonNumber((Number) object);
    } else if (object instanceof String) {
        return new ServerJsonString((String) object);
    } else if (object instanceof org.json.JSONObject) {
        return new ServerJsonObject((org.json.JSONObject) object);
    } else if (object instanceof org.json.JSONArray) {
        return new ServerJsonArray((org.json.JSONArray) object);
    } else {
        throw new IllegalArgumentException();
    }
}

@Override
public Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new HttpErrorCollection.ParseError(e));
    } catch (JSONException je) {
        return Response.error(new HttpErrorCollection.ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers, PROTOCOL_CHARSET));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
    try {
        String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        return Response.success(new JSONObject(jsonString), HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        return Response.error(new ParseError(je));
    }
}

@Override
public JSONObject put(String key, Object value) {
    try {
        if (value instanceof JSONArray) {
            put(key, (JSONArray) value);
        } else if (value instanceof JSONObject) {
            put(key, (JSONObject) value);
        } else {
            _jsonObject.put(key, value);
        }
    } catch (Exception e) {
        if (_log.isWarnEnabled()) {
            _log.warn(e, e);
        }
    }
    return this;
}

@Override
public boolean matches(Object item) {
    if (!String.class.isInstance(item)) {
        return false;
    }
    if (this.expected == null && "null".equals(item)) {
        return true;
    }
    JSONObject actual = null;
    try {
        actual = new JSONObject(new JSONTokener(item.toString()));
    } catch (JSONException e) {
        return false;
    }
    if (this.expected.length() != actual.length()) {
        return false;
    }
    JSONArray names = actual.names();
    for (int i = 0, len = names.length(); i < len; i++) {
        try {
            String name = names.getString(i);
            if (!Objects.equals(expected.get(name), actual.get(name))) {
                return false;
            }
        } catch (JSONException e) {
            return false;
        }
    }
    return true;
}

public static JavaPairRDD<String, String> XMLToJSON(JavaSparkContext jsc, JavaPairRDD<String, String> input) throws IOException {
    return input.mapToPair(new PairFunction<Tuple2<String, String>, String, String>() {

        private static final long serialVersionUID = 2878941073410454935L;

        @Override
        public Tuple2<String, String> call(Tuple2<String, String> t) throws Exception {
            String key = t._1();
            JSONObject value = new JSONObject(t._2());
            String raw = value.getString("_rawContent");
            JSONObject json = getJsonFromXml(raw);
            value.put("_jsonRep", json);
            return new Tuple2<String, String>(key, value.toString());
        }
    });
}

@SuppressWarnings("unchecked")
public JSONObject createJsonObject(Object modelObject) throws JSONException {
    Map<String, Object> model = getModelAsMap(modelObject);
    JSONObject result = new JSONObject();
    JSONUtil.putPagingInfo(result, model);
    List<HistoricProcessInstance> definitions = (List<HistoricProcessInstance>) model.get("processInstances");
    JSONArray dataArray = JSONUtil.putNewArray(result, "data");
    for (HistoricProcessInstance processDefinition : definitions) {
        JSONObject jsonTask = converter.getJSONObject(processDefinition);
        dataArray.put(jsonTask);
    }
    return result;
}

@Override
public void handleResponse(String response) {
    try {
        if (StringUtils.isEmpty(response)) {
            onFailure("请求数�为空", new NotWebDataException());
            return;
        }
        onSuccess(new JSONObject(response));
    } catch (JSONException e) {
        Log.e(TAG, "转�JSON错误", e);
        onFailure("转�JSON错误", e);
    } finally {
        onFinish();
    }
}

@Override
public void onResponse(JSONObject response) {
    switch(mType) {
        case Api.TYPE_LATEST:
            Api.parseLatestTopics(response);
            break;
        case Api.TYPE_CATEGORIES:
            Api.parseCategories(response);
            break;
    }
    ResultReceiver rr = mCallbacks.get(mType);
    if (rr != null) {
        rr.send(Activity.RESULT_OK, null);
        mCallbacks.delete(mType);
    }
}

public JSONObject loadJSONFromAsset(Context context, String filename) {
    String json = null;
    JSONObject jsonObject = null;
    try {
        InputStream is = context.getAssets().open(filename);
        int size = is.available();
        byte[] buffer = new byte[size];
        is.read(buffer);
        is.close();
        json = new String(buffer, "UTF-8");
    } catch (IOException ex) {
        ex.printStackTrace();
        return null;
    }
    try {
        jsonObject = new JSONObject(json);
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return jsonObject;
}

public Subreddit createThing() throws ThingFactoryException {
    try {
        JSONObject data = json.getJSONObject("data");
        Subreddit subreddit = new Subreddit();
        subreddit.setDisplayName(data.getString("display_name"));
        subreddit.setDescription(data.getString("description"));
        subreddit.setUrl(data.getString("url"));
        subreddit.setNumSubscribers(data.getInt("subscribers"));
        subreddit.setOver18(data.getBoolean("over18"));
        subreddit.setTitle(data.getString("title"));
        subreddit.setId(data.getString("id"));
        return subreddit;
    } catch (JSONException e) {
        throw new ThingFactoryException("Failed trying to parse JSON object into Subreddit: " + e.getMessage(), e);
    }
}

public void parse() throws JSONException {
    Iterator<?> keys = mJsonObject.keys();
    while (keys.hasNext()) {
        String key = (String) keys.next();
        if (mJsonObject.get(key) instanceof JSONObject) {
            if (LayoutAssembler.LAYOUTS.contains(key)) {
                ViewAssembler assembler = new LayoutAssembler((JSONObject) mJsonObject.get(key), mUimContext, mParent, key);
                assembler.parse();
                mRootView = (ViewGroup) assembler.getView();
            }
        }
    }
}

public static JSONObject asJsonObject(final DownloadResponse downloadResponse) {
    if (downloadResponse == null) {
        return null;
    }
    try {
        final String responseString = asResponseString(downloadResponse);
        final JSONTokener tokener = new JSONTokener(responseString);
        return new JSONObject(tokener);
    } catch (Exception e) {
        return null;
    }
}

@Override
public String format(String response) {
    try {
        Object json = new JSONTokener(response).nextValue();
        if (json instanceof JSONObject) {
            return new JSONObject(response).toString(INDENT_SPACES);
        } else if (json instanceof JSONArray) {
            return new JSONArray(response).toString(INDENT_SPACES);
        }
    } catch (JSONException e) {
        e.printStackTrace();
        Log.d(TAG, e.getMessage(), e);
    }
    return "";
}

private void parseSteps(JSONObject leg) {
    try {
        if (!leg.isNull("steps")) {
            JSONArray step = leg.getJSONArray("steps");
            for (int i = 0; i < step.length(); i++) {
                JSONObject obj = step.getJSONObject(i);
                Log.d("Step", String.valueOf(i));
                steps.add(new Steps(obj));
            }
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
}

public JSONObject loadJSONFromAsset(Context context, String filename) {
    String json = null;
    JSONObject jsonObject = null;
    try {
        InputStream is = context.getAssets().open(filename);
        int size = is.available();
        byte[] buffer = new byte[size];
        is.read(buffer);
        is.close();
        json = new String(buffer, "UTF-8");
    } catch (IOException ex) {
        ex.printStackTrace();
        return null;
    }
    try {
        jsonObject = new JSONObject(json);
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return jsonObject;
}

public void testExtract() throws JSONException {
    JSONObject json1 = new JSONObject(json1S);
    JSONObject json2 = new JSONObject(json2S);
    ArrayList<JSONPathSpec> parts = new ArrayList<JSONPathSpec>();
    parts.add(new SimpleJSONPathSpec("a"));
    parts.add(new SimpleJSONPathSpec("b"));
    JSONPathSpec comp = new CompoundORJSONPathSpec(parts);
    TestUtils.dumpMatch("json1", comp.extract(json1));
    TestUtils.assertLoLMatches(new String[][] { { "A" } }, comp.extract(json1));
    TestUtils.assertLoLMatches(new String[][] { { "B" } }, comp.extract(json2));
}

public static TypeMetaData valueOf(JSONObject jobj) {
    Boolean isSegmented = null;
    SegmentationDetails details = null;
    String subject = null;
    if (jobj.has("isSegmented"))
        isSegmented = jobj.getBoolean("isSegmented");
    if (jobj.has("segmentationDetails")) {
        JSONObject jdetails = jobj.getJSONObject("segmentationDetails");
        details = SegmentationDetails.valueOf(jdetails);
    }
    if (jobj.has("subject"))
        subject = jobj.getString("subject");
    return new TypeMetaData(isSegmented, details, subject);
}

public static void getAll(final ResponseData r) {
    String currentVersion = String.valueOf(This.shared.version);
    ServerLayer.get("all?v=" + currentVersion, null, new JsonHttpResponseHandler() {

        @Override
        public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
            r.onSuccess(response);
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, Throwable throwable, JSONObject errorResponse) {
            if (statusCode == 304) {
                r.onNotModified();
                return;
            }
            String message = throwable.getMessage();
            ErrorResponse e = ErrorResponse.create(message);
            r.onFailure(e);
        }
    });
}

/*
     * passed json is response from getting likes for a post
     */
public static ReaderUserList fromJsonLikes(JSONObject json) {
    ReaderUserList users = new ReaderUserList();
    if (json == null)
        return users;
    JSONArray jsonLikes = json.optJSONArray("likes");
    if (jsonLikes != null) {
        for (int i = 0; i < jsonLikes.length(); i++) users.add(ReaderUser.fromJson(jsonLikes.optJSONObject(i)));
    }
    return users;
}

/**
     * getVimeoThumbnail is a method used to get a thumbnail url for a given vimeo video id.
     * @param vimeoId
     * @param context
     * @return
     */
public static String getVimeoThumbnail(String vimeoId, Context context) {
    try {
        String url = "http://vimeo.com/api/v2/video/" + vimeoId + ".json";
        String response = HttpHelpers.externalHttpGet(context, url).responseBody;
        JSONArray a = new JSONArray(response);
        JSONObject json = a.getJSONObject(0);
        if (json.has("thumbnail_small"))
            return json.getString("thumbnail_small");
        else
            return json.getString("thumbnail");
    } catch (Exception E) {
        return "default_video_poster.png";
    }
}

public static BlessItemViewModel convertToViewModel(JSONObject ob) {
    if (ob == null)
        return null;
    BlessItemViewModel model = new BlessItemViewModel();
    try {
        model.title = ob.optString("name");
        if (StringTool.isNullOrEmpty(model.title))
            model.title = "匿å??";
        model.content = ob.optString("content");
        String rawTimeStr = ob.optString("time");
        // Unix-like的timestamp和java的timestamp差了个1000�数
        Long rawTimeLong = Long.parseLong(rawTimeStr) * 1000;
        model.time = new Date(rawTimeLong);
    } catch (Exception e) {
        model = null;
    }
    return model;
}

public static RequestParams toRequestParams(String secretKey, JSONObject params) {
    RequestParams requestParams = new RequestParams();
    requestParams.add("secretKey", secretKey);
    try {
        Iterator<?> keys = params.keys();
        while (keys.hasNext()) {
            String key = (String) keys.next();
            requestParams.add(key, (String) params.get(key));
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return requestParams;
}

protected static Amendment fromAPI(JSONObject json) throws JSONException, ParseException, CongressException {
    if (json == null)
        throw new CongressException("Error loading amendment.");
    Amendment amendment = new Amendment();
    if (!json.isNull("amendment_id"))
        amendment.amendment_id = json.getString("amendment_id");
    if (!json.isNull("description"))
        amendment.description = json.getString("description");
    if (!json.isNull("purpose"))
        amendment.purpose = json.getString("purpose");
    if (!json.isNull("amends_bill_id"))
        amendment.amends_bill_id = json.getString("amends_bill_id");
    return amendment;
}

public JSONArray build() {
    Position result = new Position().setTimestamp(System.currentTimeMillis()).setCoords(new Coordinates().setLatitude(location.getLatitude()).setLongitude(location.getLongitude()).setAccuracy(location.getRadius()).setHeading(location.getDirection()).setSpeed(location.getSpeed()).setAltitude(location.getAltitude()));
    JSONObject extra = new JSONObject();
    try {
        extra.put("type", location.getLocType());
    } catch (JSONException e) {
        e.printStackTrace();
    }
    JSONArray message = new JSONArray();
    message.put(result.toJSON());
    message.put(extra);
    return message;
}

public static JSONObject parseHttpResponseAsJSON(HttpResponse response) throws Exception {
    InputStream responseInStr = null;
    StringBuilder builder = new StringBuilder();
    JSONObject responseJSON = null;
    //Read it in 
    HttpEntity responseEntity = response.getEntity();
    responseInStr = responseEntity.getContent();
    BufferedReader reader = new BufferedReader(new InputStreamReader(responseInStr));
    String line;
    while ((line = reader.readLine()) != null) {
        builder.append(line);
    }
    //Convert to JSON
    responseJSON = new JSONObject(builder.toString());
    Log.i("JSON : ", "JSon Object from Http response :" + responseJSON);
    return responseJSON;
}

public void setNewJSON(JSONObject jsonObject) throws JSONException {
    otherUsersLocations = new ArrayList<>(jsonObject.length());
    Iterator<String> keys = jsonObject.keys();
    while (keys.hasNext()) {
        String key = keys.next();
        JSONObject value = jsonObject.getJSONObject(key);
        Integer latitude = Integer.parseInt(value.getString("latitude"));
        Integer longitude = Integer.parseInt(value.getString("longitude"));
        otherUsersLocations.add(new GeoPoint(latitude, longitude));
    }
}

public FileExtensionFilter getFilter(final SharedPreferences prefs) {
    final JSONObject obj = getPreferenceValue(prefs);
    final Set<String> res = new HashSet<String>();
    for (final String ex : CodecType.getAllExtensions()) {
        if (!obj.has(ex) || obj.optBoolean(ex)) {
            res.add(ex);
        }
    }
    return new FileExtensionFilter(res);
}

public static String getTranslatedTextFromJson(String jsonString) {
    try {
        JSONObject root = new JSONObject(jsonString);
        JSONObject data = root.getJSONObject(DATA);
        JSONArray translations = data.getJSONArray(TRANSLATIONS);
        JSONObject translatedText = translations.getJSONObject(0);
        return translatedText.getString(TRANSLATED_TEXT);
    } catch (JSONException e) {
        Log.e(TAG, e.getMessage());
    }
    return null;
}