Example usage for org.json JSONObject getInt

List of usage examples for org.json JSONObject getInt

Introduction

In this page you can find the example usage for org.json JSONObject getInt.

Prototype

public int getInt(String key) throws JSONException 

Source Link

Document

Get the int value associated with a key.

Usage

From source file:com.qbcps.sifterclient.SifterReader.java

private String getFilterSlug() {
    String projDetailURL;//from w  w w.j  av a  2 s . co m
    int issuesPerPage;
    JSONArray status;
    JSONArray priority;
    int numStatuses;
    int numPriorities;
    boolean[] filterStatus;
    boolean[] filterPriority;
    try {
        JSONObject filters = mSifterHelper.getFiltersFile();
        if (filters.length() == 0)
            return "";
        issuesPerPage = filters.getInt(IssuesActivity.PER_PAGE);
        status = filters.getJSONArray(IssuesActivity.STATUS);
        priority = filters.getJSONArray(IssuesActivity.PRIORITY);
        numStatuses = status.length();
        numPriorities = priority.length();
        filterStatus = new boolean[numStatuses];
        filterPriority = new boolean[numPriorities];
        for (int i = 0; i < numStatuses; i++)
            filterStatus[i] = status.getBoolean(i);
        for (int i = 0; i < numPriorities; i++)
            filterPriority[i] = priority.getBoolean(i);
    } catch (Exception e) {
        e.printStackTrace();
        mSifterHelper.onException(e.toString());
        return "";
    }
    projDetailURL = "?" + IssuesActivity.PER_PAGE + "=" + issuesPerPage;
    projDetailURL += "&" + IssuesActivity.GOTO_PAGE + "=1";
    JSONObject statuses;
    JSONObject priorities;
    JSONArray statusNames;
    JSONArray priorityNames;
    try {
        JSONObject sifterJSONObject = mSifterHelper.getSifterFilters();
        statuses = sifterJSONObject.getJSONObject(IssuesActivity.STATUSES);
        priorities = sifterJSONObject.getJSONObject(IssuesActivity.PRIORITIES);
        statusNames = statuses.names();
        priorityNames = priorities.names();
    } catch (Exception e) {
        e.printStackTrace();
        mSifterHelper.onException(e.toString());
        return "";
    }
    try {
        String filterSlug = "&s=";
        for (int i = 0; i < numStatuses; i++) {
            if (filterStatus[i])
                filterSlug += String.valueOf(statuses.getInt(statusNames.getString(i))) + "-";
        }
        if (filterSlug.length() > 3) {
            filterSlug = filterSlug.substring(0, filterSlug.length() - 1);
            projDetailURL += filterSlug;
        }
        filterSlug = "&p=";
        for (int i = 0; i < numPriorities; i++) {
            if (filterPriority[i])
                filterSlug += String.valueOf(priorities.getInt(priorityNames.getString(i))) + "-";
        }
        if (filterSlug.length() > 3) {
            filterSlug = filterSlug.substring(0, filterSlug.length() - 1);
            projDetailURL += filterSlug;
        }
    } catch (JSONException e) {
        e.printStackTrace();
        mSifterHelper.onException(e.toString());
        return "";
    }
    return projDetailURL;
}

From source file:com.google.wolff.androidhunt.Hunt.java

/** Generates the entire hunt structure from JSON */
Hunt(String jsonString, Resources res, Context context) {

    soundManager = new SoundManager(context);

    try {//from   w  w  w.ja v  a  2 s .c  om
        clues = new HashMap<String, Clue>();
        clueList = new ArrayList<Clue>();
        tags = new HashMap<String, AHTag>();

        JSONObject huntObject = new JSONObject(jsonString);
        JSONArray clueObjList = huntObject.getJSONArray("clues");
        tagList = new ArrayList<AHTag>();

        int length = clueObjList.length();
        for (int i = 0; i < length; i++) {
            JSONObject clueObj = clueObjList.getJSONObject(i);

            Clue clue = new Clue(clueObj.getString("id"), clueObj.getString("displayName"),
                    clueObj.getString("displayText"), clueObj.getString("displayImage"));

            clue.shufflegroup = clueObj.getInt("shufflegroup");

            JSONArray tagObjList = clueObj.getJSONArray("tags");

            int tagLength = tagObjList.length();

            clueList.add(clue);

            for (int j = 0; j < tagLength; j++) {
                JSONObject tagObj = tagObjList.getJSONObject(j);
                AHTag tag = new AHTag(tagObj.getString("id"));
                tag.clueId = clue.id;
                clue.addTag(tag);
                tags.put(tag.id, tag);
                tagList.add(tag);
            }

            clues.put(clue.id, clue);
        }
    } catch (Exception e) {
        if (e != null)
            Log.e("JSON Parser", "Error parsing Hunt data " + e.toString());
    }

    reset();
    restore(res, context);
}

From source file:com.tnc.android.graphite.utils.GraphiteConnection.java

private static void getTargetsRecursive(ArrayList<Target> targets, String serverUrl, String targetFilter,
        int levels) throws Exception {
    BufferedReader reader = getReader(serverUrl + TARGETS_PARAM_STRING + targetFilter);

    String line;//w w w .j  a  va2  s. c o m
    if ((line = reader.readLine()) != null) {
        JSONTokener jTok = new JSONTokener(line);
        if (jTok.more()) {
            JSONArray array = (JSONArray) jTok.nextValue();
            for (int i = 0; i < array.length(); i++) {
                JSONObject obj = array.getJSONObject(i);
                String id = obj.getString("id");
                int exp = obj.getInt("expandable");
                Target t = new Target();
                t.setHash(hash);
                t.setName(id);
                if (1 == exp) {
                    t.setExpandable(true);
                }
                targets.add(t);
                if (1 == exp && 1 < levels) {
                    // Recursively parse the branch
                    getTargetsRecursive(targets, serverUrl, id + ".*", levels - 1);
                }
            }
        }
    }
}

From source file:net.jmhertlein.mcanalytics.api.request.PastOnlinePlayerCountRequest.java

@Override
public LinkedHashMap<LocalDateTime, Integer> processResponse(JSONObject response) {
    JSONObject counts = response.getJSONObject("counts");
    LinkedHashMap<LocalDateTime, Integer> ret = new LinkedHashMap<>();

    for (String s : counts.keySet()) {
        ret.put(LocalDateTime.parse(s), counts.getInt(s));
    }/*from w w w . ja  v a  2  s . com*/

    return ret;
}

From source file:com.procasy.dubarah_nocker.gcm.MyGcmPushReceiver.java

/**
 * Called when message is received./*from w  ww  .j  a  v  a  2  s. co  m*/
 *
 * @param from   SenderID of the sender.
 * @param bundle Data bundle containing message data as key/value pairs.
 *               For Set of keys use data.keySet().
 */

@Override
public void onMessageReceived(String from, Bundle bundle) {

    MainActivity.getInstance().updateNotification();

    try {

        Log.e("notify_gcm", "success , type = " + bundle.toString());

        switch (bundle.getString(GCM_TAG)) {
        case "GENERAL": {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.hourly_logo).setContentTitle(bundle.getString(TITLE_TAG))
                    .setContentText(bundle.getString(DESC_TAG));
            Intent resultIntent = new Intent(this, MainActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mBuilder.setDefaults(
                    Notification.DEFAULT_SOUND | Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE);
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            mNotificationManager.notify(12, mBuilder.build());
            mNotification = new com.procasy.dubarah_nocker.Helper.Notification(getApplicationContext());
            mNotification.open();
            try {
                ContentValues contentValues = new ContentValues();
                contentValues.put(mNotification.COL_notification_type, GENERAL_TAG);
                contentValues.put(mNotification.COL_notfication_status, 0);
                contentValues.put(mNotification.COL_notfication_title, bundle.getString(TITLE_TAG));
                contentValues.put(mNotification.COL_notfication_desc, bundle.getString(DESC_TAG));
                contentValues.put(mNotification.COL_notfication_content, bundle.getString(CONTENT_TAG));
                mNotification.insertEntry(contentValues);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mNotification.close();
            }
            break;
        }

        case "HELP": {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.hourly_logo).setContentTitle(bundle.getString(TITLE_TAG))
                    .setContentText(bundle.getString(DESC_TAG));
            Intent resultIntent = new Intent(this, MainActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mBuilder.setDefaults(
                    Notification.DEFAULT_SOUND | Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE);
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            mNotificationManager.notify(12, mBuilder.build());
            mNotification = new com.procasy.dubarah_nocker.Helper.Notification(getApplicationContext());
            mNotification.open();
            try {
                ContentValues contentValues = new ContentValues();
                contentValues.put(mNotification.COL_notification_type, HELP_TAG);
                contentValues.put(mNotification.COL_notfication_status, 0);
                contentValues.put(mNotification.COL_notfication_title, bundle.getString(TITLE_TAG));
                contentValues.put(mNotification.COL_notfication_desc, bundle.getString(DESC_TAG));
                contentValues.put(mNotification.COL_notfication_content, bundle.getString(CONTENT_TAG));
                mNotification.insertEntry(contentValues);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mNotification.close();
            }
            JSONObject content = new JSONObject(bundle.getString("content"));
            JSONObject hr = content.getJSONObject("hr");
            JSONArray album = content.getJSONArray("album");
            System.out.println(content.getInt("hr_id"));
            System.out.println(content.toString());
            Bundle bundle1 = new Bundle();
            bundle1.putString("hr_id", hr.getString("hr_id"));
            bundle1.putString("hr_user_id", hr.getString("hr_user_id"));
            bundle1.putString("hr_description", hr.getString("hr_description"));
            bundle1.putString("hr_est_date", hr.getString("hr_est_date"));
            bundle1.putString("hr_est_time", hr.getString("hr_est_time"));
            bundle1.putString("hr_skill_id", hr.getString("hr_skill_id"));
            bundle1.putString("hr_ua_id", hr.getString("hr_ua_id"));
            bundle1.putString("hr_voice_record", hr.getString("hr_voice_record"));
            bundle1.putString("hr_language", hr.getString("hr_language"));
            bundle1.putString("hr_lat", hr.getString("hr_lat"));
            bundle1.putString("hr_lon", hr.getString("hr_lon"));
            bundle1.putString("hr_address", hr.getString("hr_address"));
            ArrayList<String> array = new ArrayList<>();
            for (int i = 0; i < album.length(); i++) {
                JSONObject object = album.getJSONObject(i);
                array.add(object.getString("ahr_img"));
            }
            bundle1.putStringArrayList("album", array);

            Intent intent = (new Intent(getApplicationContext(), JobRequestActivity.class));
            intent.putExtras(bundle1);
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            getApplicationContext().startActivity(intent);

            break;
        }

        case "APPOINTEMENT": {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.hourly_logo).setContentTitle(bundle.getString(TITLE_TAG))
                    .setContentText(bundle.getString(DESC_TAG));
            Intent resultIntent = new Intent(this, MainActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mBuilder.setDefaults(
                    Notification.DEFAULT_SOUND | Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE);
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            mNotificationManager.notify(12, mBuilder.build());
            mNotification = new com.procasy.dubarah_nocker.Helper.Notification(getApplicationContext());
            mNotification.open();
            try {
                ContentValues contentValues = new ContentValues();
                contentValues.put(mNotification.COL_notification_type, APPOINTEMENT_TAG);
                contentValues.put(mNotification.COL_notfication_status, 0);
                contentValues.put(mNotification.COL_notfication_title, bundle.getString(TITLE_TAG));
                contentValues.put(mNotification.COL_notfication_desc, bundle.getString(DESC_TAG));
                contentValues.put(mNotification.COL_notfication_content, bundle.getString(CONTENT_TAG));
                mNotification.insertEntry(contentValues);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mNotification.close();
            }
            break;
        }

        case "QOUTA_USER": {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.hourly_logo).setContentTitle(bundle.getString(TITLE_TAG))
                    .setContentText(bundle.getString(DESC_TAG));
            Intent resultIntent = new Intent(this, MainActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mBuilder.setDefaults(
                    Notification.DEFAULT_SOUND | Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE);
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            mNotificationManager.notify(12, mBuilder.build());
            mNotification = new com.procasy.dubarah_nocker.Helper.Notification(getApplicationContext());
            mNotification.open();
            try {
                ContentValues contentValues = new ContentValues();
                contentValues.put(mNotification.COL_notification_type, USER_Qouta_TAG);
                contentValues.put(mNotification.COL_notfication_status, 0);
                contentValues.put(mNotification.COL_notfication_title, bundle.getString(TITLE_TAG));
                contentValues.put(mNotification.COL_notfication_desc, bundle.getString(DESC_TAG));
                contentValues.put(mNotification.COL_notfication_content, bundle.getString(CONTENT_TAG));
                mNotification.insertEntry(contentValues);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mNotification.close();
            }
            break;
        }

        case "QOUTA_NOCKER": {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
                    .setSmallIcon(R.drawable.hourly_logo).setContentTitle(bundle.getString(TITLE_TAG))
                    .setContentText(bundle.getString(DESC_TAG));
            Intent resultIntent = new Intent(this, MainActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mBuilder.setDefaults(
                    Notification.DEFAULT_SOUND | Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE);
            NotificationManager mNotificationManager = (NotificationManager) getSystemService(
                    Context.NOTIFICATION_SERVICE);
            mNotificationManager.notify(12, mBuilder.build());
            mNotification = new com.procasy.dubarah_nocker.Helper.Notification(getApplicationContext());
            mNotification.open();
            try {
                ContentValues contentValues = new ContentValues();
                contentValues.put(mNotification.COL_notification_type, Nocker_Qouta_TAG);
                contentValues.put(mNotification.COL_notfication_status, 0);
                contentValues.put(mNotification.COL_notfication_title, bundle.getString(TITLE_TAG));
                contentValues.put(mNotification.COL_notfication_desc, bundle.getString(DESC_TAG));
                contentValues.put(mNotification.COL_notfication_content, bundle.getString(CONTENT_TAG));
                mNotification.insertEntry(contentValues);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                mNotification.close();
            }
            break;
        }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}

From source file:com.grameenfoundation.ictchallenge.controllers.ConnectedAppREST.java

private JSONObject showFarmers(String instanceUrl, String accessToken) throws ServletException, IOException {
    CloseableHttpClient httpclient = HttpClients.createDefault();

    HttpGet httpGet = new HttpGet();

    //add key and value
    httpGet.addHeader("Authorization", "OAuth " + accessToken);

    try {/*from  w  w  w  .j  a va  2s.  co m*/

        URIBuilder builder = new URIBuilder(instanceUrl + "/services/data/v30.0/query");
        //builder.setParameter("q", "SELECT Name, Id from Account LIMIT 100");
        builder.setParameter("q",
                "SELECT Name__c,Date_Of_Birth__c,Land_size__c,Farmer_I_D__c,Picture__c from Farmer__c LIMIT 100");

        httpGet.setURI(builder.build());

        log.log(Level.INFO, "URl to salesforce {0}", builder.build().getPath());

        CloseableHttpResponse closeableresponse = httpclient.execute(httpGet);
        System.out.println("Response Status line :" + closeableresponse.getStatusLine());

        if (closeableresponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            // Now lets use the standard java json classes to work with the
            // results
            try {

                // Do the needful with entity.  
                HttpEntity entity = closeableresponse.getEntity();
                InputStream rstream = entity.getContent();
                JSONObject authResponse = new JSONObject(new JSONTokener(rstream));

                log.log(Level.INFO, "Query response: {0}", authResponse.toString(2));

                log.log(Level.INFO, "{0} record(s) returned\n\n", authResponse.getInt("totalSize"));

                return authResponse;

            } catch (JSONException e) {
                e.printStackTrace();
                throw new ServletException(e);
            }
        }
    } catch (URISyntaxException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } finally {
        httpclient.close();
    }

    return null;
}

From source file:com.grameenfoundation.ictchallenge.controllers.ConnectedAppREST.java

private JSONObject getFarmerById(String instanceUrl, String accessToken, String id)
        throws ServletException, IOException {
    CloseableHttpClient httpclient = HttpClients.createDefault();

    HttpGet httpGet = new HttpGet();

    //add key and value
    httpGet.addHeader("Authorization", "OAuth " + accessToken);

    try {//from w w w  .  j a v  a 2  s .  co m

        URIBuilder builder = new URIBuilder(instanceUrl + "/services/data/v30.0/query");
        //builder.setParameter("q", "SELECT Name, Id from Account LIMIT 100");
        builder.setParameter("q",
                "SELECT Name__c,Date_Of_Birth__c,Land_size__c,Farmer_I_D__c,Picture__c from Farmer__c "
                        + " WHERE Farmer_I_D__c=" + "'" + id + "'");

        httpGet.setURI(builder.build());

        CloseableHttpResponse closeableresponse = httpclient.execute(httpGet);
        System.out.println("Response Status line :" + closeableresponse.getStatusLine());

        if (closeableresponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            // Now lets use the standard java json classes to work with the
            // results
            try {

                // Do the needful with entity.  
                HttpEntity entity = closeableresponse.getEntity();
                InputStream rstream = entity.getContent();
                JSONObject authResponse = new JSONObject(new JSONTokener(rstream));

                log.log(Level.INFO, "Query response: {0}", authResponse.toString(2));

                log.log(Level.INFO, "{0} record(s) returned\n\n", authResponse.getInt("totalSize"));

                return authResponse;

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

            }
        }
    } catch (URISyntaxException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } catch (IOException ex) {
        Logger.getLogger(ConnectedAppREST.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
        httpclient.close();
    }

    return null;
}

From source file:org.ESLM.Parser.ExerciseFactory.java

public static Instruction createInstruction(JSONObject JSONExercise) throws BadFormedJSONExerciseException {
    switch (JSONExercise.optString("type")) {
    case ("OneAnswerQuestion"): {
        String question = JSONExercise.getString("question");
        String[] answers = createAnswers(JSONExercise.getJSONArray("answers"));
        int correctAnswerIndex = JSONExercise.getInt("correctAnswer");
        return new OneAnswerInstruction(question, answers, correctAnswerIndex);
    }/*from   w  w w .j  a v a  2s .  c o  m*/
    case ("YesNoQuestion"): {
        String question = JSONExercise.getString("question");
        boolean correctAnswer = JSONExercise.getBoolean("correctAnswer");
        return new YesNoInstruction(question, correctAnswer);
    }
    case ("SimpleQuestion"): {
        String question = JSONExercise.getString("question");
        String answer = JSONExercise.getString("answer");
        return new SimpleQuestionInstruction(question, answer);
    }
    case ("IrregularVerbExercise"): {
        String infinitive = JSONExercise.getString("infinitive");
        String pastSimple = JSONExercise.getString("pastSimple");
        String pastParticiple = JSONExercise.getString("pastParticiple");
        String[] correctAnswer = { infinitive, pastSimple, pastParticiple };
        String translation = JSONExercise.getString("translation");
        boolean alsoRegular = JSONExercise.getBoolean("alsoRegular");
        return new IrregularVerbInstruction(correctAnswer, translation, alsoRegular);
    }
    case ("VocabularyExercise"): {
        String sourceLanguage = JSONExercise.getString("sourceLanguage");
        String goalLanguage = JSONExercise.getString("goalLanguage");
        JSONArray JSONVocabularyList = JSONExercise.getJSONArray("list");
        HashMap<String, String> vocabularyList = parseVocabularyList(JSONVocabularyList);
        return new VocabularyInstruction(vocabularyList, sourceLanguage, goalLanguage);
    }
    default:
        throw new BadFormedJSONExerciseException("No type or unknown type of exercise.", JSONExercise);
    }
}

From source file:de.langerhans.wallet.ui.send.RequestWalletBalanceTask.java

public void requestWalletBalance(final Address address) {
    backgroundHandler.post(new Runnable() {
        @Override/*  w  ww  . j a v  a  2  s. c o m*/
        public void run() {
            // Use either dogechain or chain.so
            List<String> urls = new ArrayList<String>(2);
            urls.add(Constants.DOGECHAIN_API_URL);
            urls.add(Constants.CHAINSO_API_URL);
            Collections.shuffle(urls, new Random(System.nanoTime()));

            final StringBuilder url = new StringBuilder(urls.get(0));
            url.append(address.toString());

            log.debug("trying to request wallet balance from {}", url);

            HttpURLConnection connection = null;
            Reader reader = null;

            try {
                connection = (HttpURLConnection) new URL(url.toString()).openConnection();

                connection.setInstanceFollowRedirects(false);
                connection.setConnectTimeout(Constants.HTTP_TIMEOUT_MS);
                connection.setReadTimeout(Constants.HTTP_TIMEOUT_MS);
                connection.setUseCaches(false);
                connection.setDoInput(true);
                connection.setDoOutput(false);

                connection.setRequestMethod("GET");
                if (userAgent != null)
                    connection.addRequestProperty("User-Agent", userAgent);
                connection.connect();

                final int responseCode = connection.getResponseCode();
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    reader = new InputStreamReader(new BufferedInputStream(connection.getInputStream(), 1024),
                            Charsets.UTF_8);
                    final StringBuilder content = new StringBuilder();
                    Io.copy(reader, content);

                    final JSONObject json = new JSONObject(content.toString());

                    final int success = json.getInt("success");
                    if (success != 1)
                        throw new IOException("api status " + success + " when fetching unspent outputs");

                    final JSONArray jsonOutputs = json.getJSONArray("unspent_outputs");

                    final Map<Sha256Hash, Transaction> transactions = new HashMap<Sha256Hash, Transaction>(
                            jsonOutputs.length());

                    for (int i = 0; i < jsonOutputs.length(); i++) {
                        final JSONObject jsonOutput = jsonOutputs.getJSONObject(i);

                        final Sha256Hash uxtoHash = new Sha256Hash(jsonOutput.getString("tx_hash"));
                        final int uxtoIndex = jsonOutput.getInt("tx_output_n");
                        final byte[] uxtoScriptBytes = HEX.decode(jsonOutput.getString("script"));
                        final Coin uxtoValue = Coin.valueOf(Long.parseLong(jsonOutput.getString("value")));

                        Transaction tx = transactions.get(uxtoHash);
                        if (tx == null) {
                            tx = new FakeTransaction(Constants.NETWORK_PARAMETERS, uxtoHash);
                            tx.getConfidence().setConfidenceType(ConfidenceType.BUILDING);
                            transactions.put(uxtoHash, tx);
                        }

                        if (tx.getOutputs().size() > uxtoIndex)
                            throw new IllegalStateException("cannot reach index " + uxtoIndex
                                    + ", tx already has " + tx.getOutputs().size() + " outputs");

                        // fill with dummies
                        while (tx.getOutputs().size() < uxtoIndex)
                            tx.addOutput(new TransactionOutput(Constants.NETWORK_PARAMETERS, tx,
                                    Coin.NEGATIVE_SATOSHI, new byte[] {}));

                        // add the real output
                        final TransactionOutput output = new TransactionOutput(Constants.NETWORK_PARAMETERS, tx,
                                uxtoValue, uxtoScriptBytes);
                        tx.addOutput(output);
                    }

                    log.info("fetched unspent outputs from {}", url);

                    onResult(transactions.values());
                } else {
                    final String responseMessage = connection.getResponseMessage();

                    log.info("got http error '{}: {}' from {}", responseCode, responseMessage, url);

                    onFail(R.string.error_http, responseCode, responseMessage);
                }
            } catch (final JSONException x) {
                log.info("problem parsing json from " + url, x);

                onFail(R.string.error_parse, x.getMessage());
            } catch (final IOException x) {
                log.info("problem querying unspent outputs from " + url, x);

                onFail(R.string.error_io, x.getMessage());
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (final IOException x) {
                        // swallow
                    }
                }

                if (connection != null)
                    connection.disconnect();
            }
        }
    });
}

From source file:com.piusvelte.sonet.SonetNotifications.java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    final ProgressDialog loadingDialog = new ProgressDialog(this);
    final AsyncTask<Integer, String, Boolean> asyncTask = new AsyncTask<Integer, String, Boolean>() {

        @Override//  ww w  .  ja  v  a2s.c  o  m
        protected Boolean doInBackground(Integer... arg0) {
            if (arg0[0] == R.id.menu_notifications_refresh) {
                // select all accounts with notifications set
                Cursor widgets = getContentResolver().query(
                        Widgets_settings.getDistinctContentUri(SonetNotifications.this),
                        new String[] { Widgets.ACCOUNT }, Widgets.ACCOUNT + "!=-1 and (" + Widgets.LIGHTS
                                + "=1 or " + Widgets.VIBRATE + "=1 or " + Widgets.SOUND + "=1)",
                        null, null);
                if (widgets.moveToFirst()) {
                    mSonetCrypto = SonetCrypto.getInstance(getApplicationContext());
                    HttpClient httpClient = SonetHttpClient.getThreadSafeClient(getApplicationContext());
                    while (!widgets.isAfterLast()) {
                        long accountId = widgets.getLong(0);
                        ArrayList<String> notificationSids = new ArrayList<String>();
                        Cursor account = getContentResolver().query(
                                Accounts.getContentUri(SonetNotifications.this),
                                new String[] { Accounts.TOKEN, Accounts.SECRET, Accounts.SERVICE,
                                        Accounts.SID },
                                Accounts._ID + "=?", new String[] { Long.toString(accountId) }, null);
                        if (account.moveToFirst()) {
                            // for each account, for each notification, check for updates
                            // if there are no updates past 24hrs and cleared, delete
                            String token = mSonetCrypto.Decrypt(account.getString(0));
                            String secret = mSonetCrypto.Decrypt(account.getString(1));
                            int service = account.getInt(2);
                            String accountEsid = mSonetCrypto.Decrypt(account.getString(3));
                            mSimpleDateFormat = null;
                            if (service == TWITTER) {
                                Cursor currentNotifications = getContentResolver().query(
                                        Notifications.getContentUri(SonetNotifications.this),
                                        new String[] { Notifications.SID }, Notifications.ACCOUNT + "=?",
                                        new String[] { Long.toString(accountId) }, null);
                                // loop over notifications
                                if (currentNotifications.moveToFirst()) {
                                    // store sids, to avoid duplicates when requesting the latest feed
                                    String sid = mSonetCrypto.Decrypt(currentNotifications.getString(0));
                                    if (!notificationSids.contains(sid)) {
                                        notificationSids.add(sid);
                                    }
                                }
                                currentNotifications.close();
                                // limit to newest status
                                SonetOAuth sonetOAuth = new SonetOAuth(BuildConfig.TWITTER_KEY,
                                        BuildConfig.TWITTER_SECRET, token, secret);
                                String last_sid = null;
                                Cursor last_status = getContentResolver().query(
                                        Statuses.getContentUri(SonetNotifications.this),
                                        new String[] { Statuses.SID }, Statuses.ACCOUNT + "=?",
                                        new String[] { Long.toString(accountId) },
                                        Statuses.CREATED + " ASC LIMIT 1");
                                if (last_status.moveToFirst()) {
                                    last_sid = mSonetCrypto.Decrypt(last_status.getString(0));
                                }
                                last_status.close();
                                // get all mentions since the oldest status for this account
                                String response = SonetHttpClient.httpResponse(httpClient,
                                        sonetOAuth.getSignedRequest(
                                                new HttpGet(String.format(TWITTER_MENTIONS, TWITTER_BASE_URL,
                                                        last_sid != null
                                                                ? String.format(TWITTER_SINCE_ID, last_sid)
                                                                : ""))));
                                if (response != null) {
                                    try {
                                        JSONArray comments = new JSONArray(response);
                                        for (int i = 0, i2 = comments.length(); i < i2; i++) {
                                            JSONObject comment = comments.getJSONObject(i);
                                            JSONObject user = comment.getJSONObject(Suser);
                                            if (!user.getString(Sid).equals(accountEsid)
                                                    && !notificationSids.contains(comment.getString(Sid))) {
                                                String friend = user.getString(Sname);
                                                addNotification(comment.getString(Sid), user.getString(Sid),
                                                        friend, comment.getString("text"),
                                                        parseDate(comment.getString("created_at"),
                                                                TWITTER_DATE_FORMAT),
                                                        accountId, friend + " mentioned you on Twitter");
                                            }
                                        }
                                    } catch (JSONException e) {
                                        Log.e(TAG, service + ":" + e.toString());
                                    }
                                }
                            } else if (service == IDENTICA) {
                                Cursor currentNotifications = getContentResolver().query(
                                        Notifications.getContentUri(SonetNotifications.this),
                                        new String[] { Notifications.SID }, Notifications.ACCOUNT + "=?",
                                        new String[] { Long.toString(accountId) }, null);
                                // loop over notifications
                                if (currentNotifications.moveToFirst()) {
                                    // store sids, to avoid duplicates when requesting the latest feed
                                    String sid = mSonetCrypto.Decrypt(currentNotifications.getString(0));
                                    if (!notificationSids.contains(sid)) {
                                        notificationSids.add(sid);
                                    }
                                }
                                currentNotifications.close();
                                // limit to newest status
                                SonetOAuth sonetOAuth = new SonetOAuth(BuildConfig.IDENTICA_KEY,
                                        BuildConfig.IDENTICA_SECRET, token, secret);
                                String last_sid = null;
                                Cursor last_status = getContentResolver().query(
                                        Statuses.getContentUri(SonetNotifications.this),
                                        new String[] { Statuses.SID }, Statuses.ACCOUNT + "=?",
                                        new String[] { Long.toString(accountId) },
                                        Statuses.CREATED + " ASC LIMIT 1");
                                if (last_status.moveToFirst()) {
                                    last_sid = mSonetCrypto.Decrypt(last_status.getString(0));
                                }
                                last_status.close();
                                // get all mentions since the oldest status for this account
                                String response = SonetHttpClient.httpResponse(httpClient,
                                        sonetOAuth.getSignedRequest(
                                                new HttpGet(String.format(IDENTICA_MENTIONS, IDENTICA_BASE_URL,
                                                        last_sid != null
                                                                ? String.format(IDENTICA_SINCE_ID, last_sid)
                                                                : ""))));
                                if (response != null) {
                                    try {
                                        JSONArray comments = new JSONArray(response);
                                        for (int i = 0, i2 = comments.length(); i < i2; i++) {
                                            JSONObject comment = comments.getJSONObject(i);
                                            JSONObject user = comment.getJSONObject(Suser);
                                            if (!user.getString(Sid).equals(accountEsid)
                                                    && !notificationSids.contains(comment.getString(Sid))) {
                                                String friend = user.getString(Sname);
                                                addNotification(comment.getString(Sid), user.getString(Sid),
                                                        friend, comment.getString("text"),
                                                        parseDate(comment.getString("created_at"),
                                                                TWITTER_DATE_FORMAT),
                                                        accountId, friend + " mentioned you on Identi.ca");
                                            }
                                        }
                                    } catch (JSONException e) {
                                        Log.e(TAG, service + ":" + e.toString());
                                    }
                                }
                            } else {
                                Cursor currentNotifications = getContentResolver().query(
                                        Notifications.getContentUri(SonetNotifications.this),
                                        new String[] { Notifications._ID, Notifications.SID,
                                                Notifications.UPDATED, Notifications.CLEARED,
                                                Notifications.ESID },
                                        Notifications.ACCOUNT + "=?", new String[] { Long.toString(accountId) },
                                        null);
                                if (currentNotifications.moveToFirst()) {
                                    String response;
                                    SonetOAuth sonetOAuth;
                                    switch (service) {
                                    case FACEBOOK:
                                        // loop over notifications
                                        while (!currentNotifications.isAfterLast()) {
                                            long notificationId = currentNotifications.getLong(0);
                                            String sid = mSonetCrypto
                                                    .Decrypt(currentNotifications.getString(1));
                                            long updated = currentNotifications.getLong(2);
                                            boolean cleared = currentNotifications.getInt(3) == 1;
                                            // store sids, to avoid duplicates when requesting the latest feed
                                            if (!notificationSids.contains(sid)) {
                                                notificationSids.add(sid);
                                            }
                                            // get comments for current notifications
                                            if ((response = SonetHttpClient.httpResponse(httpClient,
                                                    new HttpGet(
                                                            String.format(FACEBOOK_COMMENTS, FACEBOOK_BASE_URL,
                                                                    sid, Saccess_token, token)))) != null) {
                                                // check for a newer post, if it's the user's own, then set CLEARED=0
                                                try {
                                                    JSONArray comments = new JSONObject(response)
                                                            .getJSONArray(Sdata);
                                                    int i2 = comments.length();
                                                    if (i2 > 0) {
                                                        for (int i = 0; i < i2; i++) {
                                                            JSONObject comment = comments.getJSONObject(i);
                                                            long created_time = comment.getLong(Screated_time)
                                                                    * 1000;
                                                            if (created_time > updated) {
                                                                // new comment
                                                                ContentValues values = new ContentValues();
                                                                values.put(Notifications.UPDATED, created_time);
                                                                JSONObject from = comment.getJSONObject(Sfrom);
                                                                if (accountEsid.equals(from.getString(Sid))) {
                                                                    // user's own comment, clear the notification
                                                                    values.put(Notifications.CLEARED, 1);
                                                                } else if (cleared) {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    from.getString(Sname)));
                                                                    values.put(Notifications.CLEARED, 0);
                                                                } else {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    from.getString(Sname)
                                                                                            + " and others"));
                                                                }
                                                                getContentResolver().update(
                                                                        Notifications.getContentUri(
                                                                                SonetNotifications.this),
                                                                        values, Notifications._ID + "=?",
                                                                        new String[] { Long
                                                                                .toString(notificationId) });
                                                            }
                                                        }
                                                    }
                                                } catch (JSONException e) {
                                                    Log.e(TAG, service + ":" + e.toString());
                                                }
                                            }
                                            currentNotifications.moveToNext();
                                        }
                                        // check the latest feed
                                        if ((response = SonetHttpClient.httpResponse(httpClient,
                                                new HttpGet(String.format(FACEBOOK_HOME, FACEBOOK_BASE_URL,
                                                        Saccess_token, token)))) != null) {
                                            try {
                                                JSONArray jarr = new JSONObject(response).getJSONArray(Sdata);
                                                // if there are updates, clear the cache
                                                int d2 = jarr.length();
                                                if (d2 > 0) {
                                                    for (int d = 0; d < d2; d++) {
                                                        JSONObject o = jarr.getJSONObject(d);
                                                        String sid = o.getString(Sid);
                                                        // if already notified, ignore
                                                        if (!notificationSids.contains(sid)) {
                                                            // only parse status types, not photo, video or link
                                                            if (o.has(Stype) && o.has(Sfrom)) {
                                                                JSONObject f = o.getJSONObject(Sfrom);
                                                                if (f.has(Sname) && f.has(Sid)) {
                                                                    String notification = null;
                                                                    String esid = f.getString(Sid);
                                                                    String friend = f.getString(Sname);
                                                                    if (o.has(Sto)) {
                                                                        // handle wall messages from one friend to another
                                                                        JSONObject t = o.getJSONObject(Sto);
                                                                        if (t.has(Sdata)) {
                                                                            JSONObject n = t.getJSONArray(Sdata)
                                                                                    .getJSONObject(0);
                                                                            if (n.has(Sname)) {
                                                                                if (n.has(Sid) && (n
                                                                                        .getString(Sid)
                                                                                        .equals(accountEsid))) {
                                                                                    notification = String
                                                                                            .format(getString(
                                                                                                    R.string.friendcommented),
                                                                                                    friend);
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    int commentCount = 0;
                                                                    if (o.has(Scomments)) {
                                                                        JSONObject jo = o
                                                                                .getJSONObject(Scomments);
                                                                        if (jo.has(Sdata)) {
                                                                            JSONArray comments = jo
                                                                                    .getJSONArray(Sdata);
                                                                            commentCount = comments.length();
                                                                            // notifications
                                                                            if ((sid != null)
                                                                                    && (commentCount > 0)) {
                                                                                // default hasCommented to whether or not these comments are for the own user's status
                                                                                boolean hasCommented = notification != null
                                                                                        || esid.equals(
                                                                                                accountEsid);
                                                                                for (int c2 = 0; c2 < commentCount; c2++) {
                                                                                    JSONObject c3 = comments
                                                                                            .getJSONObject(c2);
                                                                                    if (c3.has(Sfrom)) {
                                                                                        JSONObject c4 = c3
                                                                                                .getJSONObject(
                                                                                                        Sfrom);
                                                                                        if (c4.getString(Sid)
                                                                                                .equals(accountEsid)) {
                                                                                            if (!hasCommented) {
                                                                                                // the user has commented on this thread, notify any updates
                                                                                                hasCommented = true;
                                                                                            }
                                                                                            // clear any notifications, as the user is already aware
                                                                                            if (notification != null) {
                                                                                                notification = null;
                                                                                            }
                                                                                        } else if (hasCommented) {
                                                                                            // don't notify about user's own comments
                                                                                            // send the parent comment sid
                                                                                            notification = String
                                                                                                    .format(getString(
                                                                                                            R.string.friendcommented),
                                                                                                            c4.getString(
                                                                                                                    Sname));
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if (notification != null) {
                                                                        String message = o.has(Smessage)
                                                                                ? o.getString(Smessage)
                                                                                : null;
                                                                        if (!o.getString(Stype).equals(Sstatus)
                                                                                && o.has(Slink)) {
                                                                            message = message == null
                                                                                    ? "[" + o.getString(Stype)
                                                                                            + "]"
                                                                                    : "[" + o.getString(Stype)
                                                                                            + "]";
                                                                        }
                                                                        // new notification
                                                                        addNotification(sid, esid, friend,
                                                                                message,
                                                                                o.getLong(Screated_time) * 1000,
                                                                                accountId, notification);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            } catch (JSONException e) {
                                                Log.e(TAG, service + ":" + e.toString());
                                            }
                                        }
                                        break;
                                    case MYSPACE:
                                        sonetOAuth = new SonetOAuth(BuildConfig.MYSPACE_KEY,
                                                BuildConfig.MYSPACE_SECRET, token, secret);
                                        // loop over notifications
                                        while (!currentNotifications.isAfterLast()) {
                                            long notificationId = currentNotifications.getLong(0);
                                            String sid = mSonetCrypto
                                                    .Decrypt(currentNotifications.getString(1));
                                            long updated = currentNotifications.getLong(2);
                                            boolean cleared = currentNotifications.getInt(3) == 1;
                                            String esid = mSonetCrypto
                                                    .Decrypt(currentNotifications.getString(4));
                                            // store sids, to avoid duplicates when requesting the latest feed
                                            if (!notificationSids.contains(sid)) {
                                                notificationSids.add(sid);
                                            }
                                            // get comments for current notifications
                                            if ((response = SonetHttpClient.httpResponse(httpClient,
                                                    sonetOAuth.getSignedRequest(new HttpGet(
                                                            String.format(MYSPACE_URL_STATUSMOODCOMMENTS,
                                                                    MYSPACE_BASE_URL, esid, sid))))) != null) {
                                                // check for a newer post, if it's the user's own, then set CLEARED=0
                                                try {
                                                    JSONArray comments = new JSONObject(response)
                                                            .getJSONArray(Sentry);
                                                    int i2 = comments.length();
                                                    if (i2 > 0) {
                                                        for (int i = 0; i < i2; i++) {
                                                            JSONObject comment = comments.getJSONObject(i);
                                                            long created_time = parseDate(
                                                                    comment.getString(SpostedDate),
                                                                    MYSPACE_DATE_FORMAT);
                                                            if (created_time > updated) {
                                                                // new comment
                                                                ContentValues values = new ContentValues();
                                                                values.put(Notifications.UPDATED, created_time);
                                                                JSONObject author = comment
                                                                        .getJSONObject(Sauthor);
                                                                if (accountEsid.equals(author.getString(Sid))) {
                                                                    // user's own comment, clear the notification
                                                                    values.put(Notifications.CLEARED, 1);
                                                                } else if (cleared) {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    comment.getString(
                                                                                            SdisplayName)));
                                                                    values.put(Notifications.CLEARED, 0);
                                                                } else {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    comment.getString(
                                                                                            SdisplayName)
                                                                                            + " and others"));
                                                                }
                                                                getContentResolver().update(
                                                                        Notifications.getContentUri(
                                                                                SonetNotifications.this),
                                                                        values, Notifications._ID + "=?",
                                                                        new String[] { Long
                                                                                .toString(notificationId) });
                                                            }
                                                        }
                                                    }
                                                } catch (JSONException e) {
                                                    Log.e(TAG, service + ":" + e.toString());
                                                }
                                            }
                                            currentNotifications.moveToNext();
                                        }
                                        // check the latest feed
                                        if ((response = SonetHttpClient
                                                .httpResponse(httpClient,
                                                        sonetOAuth.getSignedRequest(
                                                                new HttpGet(String.format(MYSPACE_HISTORY,
                                                                        MYSPACE_BASE_URL))))) != null) {
                                            try {
                                                JSONArray jarr = new JSONObject(response).getJSONArray(Sentry);
                                                // if there are updates, clear the cache
                                                int d2 = jarr.length();
                                                if (d2 > 0) {
                                                    for (int d = 0; d < d2; d++) {
                                                        JSONObject o = jarr.getJSONObject(d);
                                                        String sid = o.getString(SstatusId);
                                                        // if already notified, ignore
                                                        if (!notificationSids.contains(sid)) {
                                                            if (o.has(Sauthor) && o.has(SrecentComments)) {
                                                                JSONObject f = o.getJSONObject(Sauthor);
                                                                if (f.has(SdisplayName) && f.has(Sid)) {
                                                                    String notification = null;
                                                                    String esid = f.getString(Sid);
                                                                    String friend = f.getString(SdisplayName);
                                                                    JSONArray comments = o
                                                                            .getJSONArray(SrecentComments);
                                                                    int commentCount = comments.length();
                                                                    // notifications
                                                                    if ((sid != null) && (commentCount > 0)) {
                                                                        // default hasCommented to whether or not these comments are for the own user's status
                                                                        boolean hasCommented = notification != null
                                                                                || esid.equals(accountEsid);
                                                                        for (int c2 = 0; c2 < commentCount; c2++) {
                                                                            JSONObject c3 = comments
                                                                                    .getJSONObject(c2);
                                                                            if (c3.has(Sauthor)) {
                                                                                JSONObject c4 = c3
                                                                                        .getJSONObject(Sauthor);
                                                                                if (c4.getString(Sid)
                                                                                        .equals(accountEsid)) {
                                                                                    if (!hasCommented) {
                                                                                        // the user has commented on this thread, notify any updates
                                                                                        hasCommented = true;
                                                                                    }
                                                                                    // clear any notifications, as the user is already aware
                                                                                    if (notification != null) {
                                                                                        notification = null;
                                                                                    }
                                                                                } else if (hasCommented) {
                                                                                    // don't notify about user's own comments
                                                                                    // send the parent comment sid
                                                                                    notification = String
                                                                                            .format(getString(
                                                                                                    R.string.friendcommented),
                                                                                                    c4.getString(
                                                                                                            SdisplayName));
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if (notification != null) {
                                                                        // new notification
                                                                        addNotification(sid, esid, friend,
                                                                                o.getString(Sstatus),
                                                                                parseDate(o.getString(
                                                                                        "moodStatusLastUpdated"),
                                                                                        MYSPACE_DATE_FORMAT),
                                                                                accountId, notification);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            } catch (JSONException e) {
                                                Log.e(TAG, service + ":" + e.toString());
                                            }
                                        }
                                        break;
                                    case FOURSQUARE:
                                        // loop over notifications
                                        while (!currentNotifications.isAfterLast()) {
                                            long notificationId = currentNotifications.getLong(0);
                                            String sid = mSonetCrypto
                                                    .Decrypt(currentNotifications.getString(1));
                                            long updated = currentNotifications.getLong(2);
                                            boolean cleared = currentNotifications.getInt(3) == 1;
                                            // store sids, to avoid duplicates when requesting the latest feed
                                            if (!notificationSids.contains(sid)) {
                                                notificationSids.add(sid);
                                            }
                                            // get comments for current notifications
                                            if ((response = SonetHttpClient.httpResponse(httpClient,
                                                    new HttpGet(String.format(FOURSQUARE_GET_CHECKIN,
                                                            FOURSQUARE_BASE_URL, sid, token)))) != null) {
                                                // check for a newer post, if it's the user's own, then set CLEARED=0
                                                try {
                                                    JSONArray comments = new JSONObject(response)
                                                            .getJSONObject(Sresponse).getJSONObject(Scheckin)
                                                            .getJSONObject(Scomments).getJSONArray(Sitems);
                                                    int i2 = comments.length();
                                                    if (i2 > 0) {
                                                        for (int i = 0; i < i2; i++) {
                                                            JSONObject comment = comments.getJSONObject(i);
                                                            long created_time = comment.getLong(ScreatedAt)
                                                                    * 1000;
                                                            if (created_time > updated) {
                                                                // new comment
                                                                ContentValues values = new ContentValues();
                                                                values.put(Notifications.UPDATED, created_time);
                                                                JSONObject user = comment.getJSONObject(Suser);
                                                                if (accountEsid.equals(user.getString(Sid))) {
                                                                    // user's own comment, clear the notification
                                                                    values.put(Notifications.CLEARED, 1);
                                                                } else if (cleared) {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    user.getString(SfirstName)
                                                                                            + " "
                                                                                            + user.getString(
                                                                                                    SlastName)));
                                                                    values.put(Notifications.CLEARED, 0);
                                                                } else {
                                                                    values.put(Notifications.NOTIFICATION,
                                                                            String.format(getString(
                                                                                    R.string.friendcommented),
                                                                                    user.getString(SfirstName)
                                                                                            + " "
                                                                                            + user.getString(
                                                                                                    SlastName)
                                                                                            + " and others"));
                                                                }
                                                                getContentResolver().update(
                                                                        Notifications.getContentUri(
                                                                                SonetNotifications.this),
                                                                        values, Notifications._ID + "=?",
                                                                        new String[] { Long
                                                                                .toString(notificationId) });
                                                            }
                                                        }
                                                    }
                                                } catch (JSONException e) {
                                                    Log.e(TAG, service + ":" + e.toString());
                                                }
                                            }
                                            currentNotifications.moveToNext();
                                        }
                                        // check the latest feed
                                        if ((response = SonetHttpClient.httpResponse(httpClient,
                                                new HttpGet(String.format(FOURSQUARE_CHECKINS,
                                                        FOURSQUARE_BASE_URL, token)))) != null) {
                                            try {
                                                JSONArray jarr = new JSONObject(response)
                                                        .getJSONObject(Sresponse).getJSONArray(Srecent);
                                                // if there are updates, clear the cache
                                                int d2 = jarr.length();
                                                if (d2 > 0) {
                                                    for (int d = 0; d < d2; d++) {
                                                        JSONObject o = jarr.getJSONObject(d);
                                                        String sid = o.getString(Sid);
                                                        // if already notified, ignore
                                                        if (!notificationSids.contains(sid)) {
                                                            if (o.has(Suser) && o.has(Scomments)) {
                                                                JSONObject f = o.getJSONObject(Suser);
                                                                if (f.has(SfirstName) && f.has(SlastName)
                                                                        && f.has(Sid)) {
                                                                    String notification = null;
                                                                    String esid = f.getString(Sid);
                                                                    String friend = f.getString(SfirstName)
                                                                            + " " + f.getString(SlastName);
                                                                    JSONArray comments = o
                                                                            .getJSONArray(Scomments);
                                                                    int commentCount = comments.length();
                                                                    // notifications
                                                                    if (commentCount > 0) {
                                                                        // default hasCommented to whether or not these comments are for the own user's status
                                                                        boolean hasCommented = notification != null
                                                                                || esid.equals(accountEsid);
                                                                        for (int c2 = 0; c2 < commentCount; c2++) {
                                                                            JSONObject c3 = comments
                                                                                    .getJSONObject(c2);
                                                                            if (c3.has(Suser)) {
                                                                                JSONObject c4 = c3
                                                                                        .getJSONObject(Suser);
                                                                                if (c4.getString(Sid)
                                                                                        .equals(accountEsid)) {
                                                                                    if (!hasCommented) {
                                                                                        // the user has commented on this thread, notify any updates
                                                                                        hasCommented = true;
                                                                                    }
                                                                                    // clear any notifications, as the user is already aware
                                                                                    if (notification != null) {
                                                                                        notification = null;
                                                                                    }
                                                                                } else if (hasCommented) {
                                                                                    // don't notify about user's own comments
                                                                                    // send the parent comment sid
                                                                                    notification = String
                                                                                            .format(getString(
                                                                                                    R.string.friendcommented),
                                                                                                    c4.getString(
                                                                                                            SfirstName)
                                                                                                            + " "
                                                                                                            + c4.getString(
                                                                                                                    SlastName));
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    if (notification != null) {
                                                                        String message = "";
                                                                        if (o.has(Sshout)) {
                                                                            message = o.getString(Sshout)
                                                                                    + "\n";
                                                                        }
                                                                        if (o.has(Svenue)) {
                                                                            JSONObject venue = o
                                                                                    .getJSONObject(Svenue);
                                                                            if (venue.has(Sname)) {
                                                                                message += "@" + venue
                                                                                        .getString(Sname);
                                                                            }
                                                                        }
                                                                        // new notification
                                                                        addNotification(sid, esid, friend,
                                                                                message,
                                                                                o.getLong(ScreatedAt) * 1000,
                                                                                accountId, notification);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            } catch (JSONException e) {
                                                Log.e(TAG, service + ":" + e.toString());
                                            }
                                        }
                                        break;
                                    case LINKEDIN:
                                        sonetOAuth = new SonetOAuth(BuildConfig.LINKEDIN_KEY,
                                                BuildConfig.LINKEDIN_SECRET, token, secret);
                                        // loop over notifications
                                        while (!currentNotifications.isAfterLast()) {
                                            long notificationId = currentNotifications.getLong(0);
                                            String sid = mSonetCrypto
                                                    .Decrypt(currentNotifications.getString(1));
                                            long updated = currentNotifications.getLong(2);
                                            boolean cleared = currentNotifications.getInt(3) == 1;
                                            // store sids, to avoid duplicates when requesting the latest feed
                                            if (!notificationSids.contains(sid)) {
                                                notificationSids.add(sid);
                                            }
                                            // get comments for current notifications
                                            HttpGet httpGet = new HttpGet(String
                                                    .format(LINKEDIN_UPDATE_COMMENTS, LINKEDIN_BASE_URL, sid));
                                            for (String[] header : LINKEDIN_HEADERS)
                                                httpGet.setHeader(header[0], header[1]);
                                            if ((response = SonetHttpClient.httpResponse(httpClient,
                                                    sonetOAuth.getSignedRequest(httpGet))) != null) {
                                                // check for a newer post, if it's the user's own, then set CLEARED=0
                                                try {
                                                    JSONObject jsonResponse = new JSONObject(response);
                                                    if (jsonResponse.has(S_total)
                                                            && (jsonResponse.getInt(S_total) != 0)) {
                                                        JSONArray comments = jsonResponse.getJSONArray(Svalues);
                                                        int i2 = comments.length();
                                                        if (i2 > 0) {
                                                            for (int i = 0; i < i2; i++) {
                                                                JSONObject comment = comments.getJSONObject(i);
                                                                long created_time = comment.getLong(Stimestamp);
                                                                if (created_time > updated) {
                                                                    // new comment
                                                                    ContentValues values = new ContentValues();
                                                                    values.put(Notifications.UPDATED,
                                                                            created_time);
                                                                    JSONObject person = comment
                                                                            .getJSONObject(Sperson);
                                                                    if (accountEsid
                                                                            .equals(person.getString(Sid))) {
                                                                        // user's own comment, clear the notification
                                                                        values.put(Notifications.CLEARED, 1);
                                                                    } else if (cleared) {
                                                                        values.put(Notifications.NOTIFICATION,
                                                                                String.format(getString(
                                                                                        R.string.friendcommented),
                                                                                        person.getString(
                                                                                                SfirstName)
                                                                                                + " "
                                                                                                + person.getString(
                                                                                                        SlastName)));
                                                                        values.put(Notifications.CLEARED, 0);
                                                                    } else {
                                                                        values.put(Notifications.NOTIFICATION,
                                                                                String.format(getString(
                                                                                        R.string.friendcommented),
                                                                                        person.getString(
                                                                                                SfirstName)
                                                                                                + " "
                                                                                                + person.getString(
                                                                                                        SlastName)
                                                                                                + " and others"));
                                                                    }
                                                                    getContentResolver().update(
                                                                            Notifications.getContentUri(
                                                                                    SonetNotifications.this),
                                                                            values, Notifications._ID + "=?",
                                                                            new String[] { Long.toString(
                                                                                    notificationId) });
                                                                }
                                                            }
                                                        }
                                                    }
                                                } catch (JSONException e) {
                                                    Log.e(TAG, service + ":" + e.toString());
                                                }
                                            }
                                            currentNotifications.moveToNext();
                                        }
                                        // check the latest feed
                                        HttpGet httpGet = new HttpGet(
                                                String.format(LINKEDIN_UPDATES, LINKEDIN_BASE_URL));
                                        for (String[] header : LINKEDIN_HEADERS) {
                                            httpGet.setHeader(header[0], header[1]);
                                        }
                                        if ((response = SonetHttpClient.httpResponse(httpClient,
                                                sonetOAuth.getSignedRequest(httpGet))) != null) {
                                            try {
                                                JSONArray jarr = new JSONObject(response).getJSONArray(Svalues);
                                                // if there are updates, clear the cache
                                                int d2 = jarr.length();
                                                if (d2 > 0) {
                                                    for (int d = 0; d < d2; d++) {
                                                        JSONObject o = jarr.getJSONObject(d);
                                                        String sid = o.getString(SupdateKey);
                                                        // if already notified, ignore
                                                        if (!notificationSids.contains(sid)) {
                                                            String updateType = o.getString(SupdateType);
                                                            JSONObject updateContent = o
                                                                    .getJSONObject(SupdateContent);
                                                            if (LinkedIn_UpdateTypes.contains(updateType)
                                                                    && updateContent.has(Sperson)) {
                                                                JSONObject f = updateContent
                                                                        .getJSONObject(Sperson);
                                                                if (f.has(SfirstName) && f.has(SlastName)
                                                                        && f.has(Sid)
                                                                        && o.has(SupdateComments)) {
                                                                    JSONObject updateComments = o
                                                                            .getJSONObject(SupdateComments);
                                                                    if (updateComments.has(Svalues)) {
                                                                        String notification = null;
                                                                        String esid = f.getString(Sid);
                                                                        JSONArray comments = updateComments
                                                                                .getJSONArray(Svalues);
                                                                        int commentCount = comments.length();
                                                                        // notifications
                                                                        if (commentCount > 0) {
                                                                            // default hasCommented to whether or not these comments are for the own user's status
                                                                            boolean hasCommented = notification != null
                                                                                    || esid.equals(accountEsid);
                                                                            for (int c2 = 0; c2 < commentCount; c2++) {
                                                                                JSONObject c3 = comments
                                                                                        .getJSONObject(c2);
                                                                                if (c3.has(Sperson)) {
                                                                                    JSONObject c4 = c3
                                                                                            .getJSONObject(
                                                                                                    Sperson);
                                                                                    if (c4.getString(Sid)
                                                                                            .equals(accountEsid)) {
                                                                                        if (!hasCommented) {
                                                                                            // the user has commented on this thread, notify any updates
                                                                                            hasCommented = true;
                                                                                        }
                                                                                        // clear any notifications, as the user is already aware
                                                                                        if (notification != null) {
                                                                                            notification = null;
                                                                                        }
                                                                                    } else if (hasCommented) {
                                                                                        // don't notify about user's own comments
                                                                                        // send the parent comment sid
                                                                                        notification = String
                                                                                                .format(getString(
                                                                                                        R.string.friendcommented),
                                                                                                        c4.getString(
                                                                                                                SfirstName)
                                                                                                                + " "
                                                                                                                + c4.getString(
                                                                                                                        SlastName));
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if (notification != null) {
                                                                            String update = LinkedIn_UpdateTypes
                                                                                    .getMessage(updateType);
                                                                            if (LinkedIn_UpdateTypes.APPS.name()
                                                                                    .equals(updateType)) {
                                                                                if (f.has(SpersonActivities)) {
                                                                                    JSONObject personActivities = f
                                                                                            .getJSONObject(
                                                                                                    SpersonActivities);
                                                                                    if (personActivities
                                                                                            .has(Svalues)) {
                                                                                        JSONArray updates = personActivities
                                                                                                .getJSONArray(
                                                                                                        Svalues);
                                                                                        for (int u = 0, u2 = updates
                                                                                                .length(); u < u2; u++) {
                                                                                            update += updates
                                                                                                    .getJSONObject(
                                                                                                            u)
                                                                                                    .getString(
                                                                                                            Sbody);
                                                                                            if (u < (updates
                                                                                                    .length()
                                                                                                    - 1))
                                                                                                update += ", ";
                                                                                        }
                                                                                    }
                                                                                }
                                                                            } else if (LinkedIn_UpdateTypes.CONN
                                                                                    .name()
                                                                                    .equals(updateType)) {
                                                                                if (f.has(Sconnections)) {
                                                                                    JSONObject connections = f
                                                                                            .getJSONObject(
                                                                                                    Sconnections);
                                                                                    if (connections
                                                                                            .has(Svalues)) {
                                                                                        JSONArray updates = connections
                                                                                                .getJSONArray(
                                                                                                        Svalues);
                                                                                        for (int u = 0, u2 = updates
                                                                                                .length(); u < u2; u++) {
                                                                                            update += updates
                                                                                                    .getJSONObject(
                                                                                                            u)
                                                                                                    .getString(
                                                                                                            SfirstName)
                                                                                                    + " "
                                                                                                    + updates
                                                                                                            .getJSONObject(
                                                                                                                    u)
                                                                                                            .getString(
                                                                                                                    SlastName);
                                                                                            if (u < (updates
                                                                                                    .length()
                                                                                                    - 1))
                                                                                                update += ", ";
                                                                                        }
                                                                                    }
                                                                                }
                                                                            } else if (LinkedIn_UpdateTypes.JOBP
                                                                                    .name()
                                                                                    .equals(updateType)) {
                                                                                if (updateContent.has(Sjob)
                                                                                        && updateContent
                                                                                                .getJSONObject(
                                                                                                        Sjob)
                                                                                                .has(Sposition)
                                                                                        && updateContent
                                                                                                .getJSONObject(
                                                                                                        Sjob)
                                                                                                .getJSONObject(
                                                                                                        Sposition)
                                                                                                .has(Stitle))
                                                                                    update += updateContent
                                                                                            .getJSONObject(Sjob)
                                                                                            .getJSONObject(
                                                                                                    Sposition)
                                                                                            .getString(Stitle);
                                                                            } else if (LinkedIn_UpdateTypes.JGRP
                                                                                    .name()
                                                                                    .equals(updateType)) {
                                                                                if (f.has(SmemberGroups)) {
                                                                                    JSONObject memberGroups = f
                                                                                            .getJSONObject(
                                                                                                    SmemberGroups);
                                                                                    if (memberGroups
                                                                                            .has(Svalues)) {
                                                                                        JSONArray updates = memberGroups
                                                                                                .getJSONArray(
                                                                                                        Svalues);
                                                                                        for (int u = 0, u2 = updates
                                                                                                .length(); u < u2; u++) {
                                                                                            update += updates
                                                                                                    .getJSONObject(
                                                                                                            u)
                                                                                                    .getString(
                                                                                                            Sname);
                                                                                            if (u < (updates
                                                                                                    .length()
                                                                                                    - 1))
                                                                                                update += ", ";
                                                                                        }
                                                                                    }
                                                                                }
                                                                            } else if (LinkedIn_UpdateTypes.PREC
                                                                                    .name()
                                                                                    .equals(updateType)) {
                                                                                if (f.has(
                                                                                        SrecommendationsGiven)) {
                                                                                    JSONObject recommendationsGiven = f
                                                                                            .getJSONObject(
                                                                                                    SrecommendationsGiven);
                                                                                    if (recommendationsGiven
                                                                                            .has(Svalues)) {
                                                                                        JSONArray updates = recommendationsGiven
                                                                                                .getJSONArray(
                                                                                                        Svalues);
                                                                                        for (int u = 0, u2 = updates
                                                                                                .length(); u < u2; u++) {
                                                                                            JSONObject recommendation = updates
                                                                                                    .getJSONObject(
                                                                                                            u);
                                                                                            JSONObject recommendee = recommendation
                                                                                                    .getJSONObject(
                                                                                                            Srecommendee);
                                                                                            if (recommendee.has(
                                                                                                    SfirstName))
                                                                                                update += recommendee
                                                                                                        .getString(
                                                                                                                SfirstName);
                                                                                            if (recommendee.has(
                                                                                                    SlastName))
                                                                                                update += recommendee
                                                                                                        .getString(
                                                                                                                SlastName);
                                                                                            if (recommendation
                                                                                                    .has(SrecommendationSnippet))
                                                                                                update += ":"
                                                                                                        + recommendation
                                                                                                                .getString(
                                                                                                                        SrecommendationSnippet);
                                                                                            if (u < (updates
                                                                                                    .length()
                                                                                                    - 1))
                                                                                                update += ", ";
                                                                                        }
                                                                                    }
                                                                                }
                                                                            } else if (LinkedIn_UpdateTypes.SHAR
                                                                                    .name().equals(updateType)
                                                                                    && f.has(ScurrentShare)) {
                                                                                JSONObject currentShare = f
                                                                                        .getJSONObject(
                                                                                                ScurrentShare);
                                                                                if (currentShare.has(Scomment))
                                                                                    update = currentShare
                                                                                            .getString(
                                                                                                    Scomment);
                                                                            }
                                                                            // new notification
                                                                            addNotification(sid, esid,
                                                                                    f.getString(SfirstName)
                                                                                            + " "
                                                                                            + f.getString(
                                                                                                    SlastName),
                                                                                    update,
                                                                                    o.getLong(Stimestamp),
                                                                                    accountId, notification);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            } catch (JSONException e) {
                                                Log.e(TAG, service + ":" + e.toString());
                                            }
                                        }
                                        break;
                                    case GOOGLEPLUS:
                                        // get new access token, need different request here
                                        HttpPost httpPost = new HttpPost(GOOGLE_ACCESS);
                                        List<NameValuePair> httpParams = new ArrayList<NameValuePair>();
                                        httpParams.add(new BasicNameValuePair("client_id",
                                                BuildConfig.GOOGLECLIENT_ID));
                                        httpParams.add(new BasicNameValuePair("client_secret",
                                                BuildConfig.GOOGLECLIENT_SECRET));
                                        httpParams.add(new BasicNameValuePair("refresh_token", token));
                                        httpParams.add(new BasicNameValuePair("grant_type", "refresh_token"));
                                        try {
                                            httpPost.setEntity(new UrlEncodedFormEntity(httpParams));
                                            if ((response = SonetHttpClient.httpResponse(httpClient,
                                                    httpPost)) != null) {
                                                JSONObject j = new JSONObject(response);
                                                if (j.has(Saccess_token)) {
                                                    String access_token = j.getString(Saccess_token);
                                                    while (!currentNotifications.isAfterLast()) {
                                                        long notificationId = currentNotifications.getLong(0);
                                                        String sid = mSonetCrypto
                                                                .Decrypt(currentNotifications.getString(1));
                                                        long updated = currentNotifications.getLong(2);
                                                        boolean cleared = currentNotifications.getInt(3) == 1;
                                                        // store sids, to avoid duplicates when requesting the latest feed
                                                        if (!notificationSids.contains(sid)) {
                                                            notificationSids.add(sid);
                                                        }
                                                        // get comments for current notifications
                                                        if ((response = SonetHttpClient.httpResponse(httpClient,
                                                                new HttpGet(String.format(GOOGLEPLUS_ACTIVITY,
                                                                        GOOGLEPLUS_BASE_URL, sid,
                                                                        access_token)))) != null) {
                                                            // check for a newer post, if it's the user's own, then set CLEARED=0
                                                            try {
                                                                JSONObject item = new JSONObject(response);
                                                                if (item.has(Sobject)) {
                                                                    JSONObject object = item
                                                                            .getJSONObject(Sobject);
                                                                    if (object.has(Sreplies)) {
                                                                        int commentCount = 0;
                                                                        JSONObject replies = object
                                                                                .getJSONObject(Sreplies);
                                                                        if (replies.has(StotalItems)) {
                                                                            //TODO: notifications
                                                                        }
                                                                    }
                                                                }
                                                            } catch (JSONException e) {
                                                                Log.e(TAG, service + ":" + e.toString());
                                                            }
                                                        }
                                                        currentNotifications.moveToNext();
                                                    }
                                                    // get new feed
                                                    if ((response = SonetHttpClient.httpResponse(httpClient,
                                                            new HttpGet(String.format(GOOGLEPLUS_ACTIVITIES,
                                                                    GOOGLEPLUS_BASE_URL, "me", "public", 20,
                                                                    access_token)))) != null) {
                                                        JSONObject r = new JSONObject(response);
                                                        if (r.has(Sitems)) {
                                                            JSONArray items = r.getJSONArray(Sitems);
                                                            for (int i1 = 0, i2 = items
                                                                    .length(); i1 < i2; i1++) {
                                                                JSONObject item = items.getJSONObject(i1);
                                                                if (item.has(Sactor) && item.has(Sobject)) {
                                                                    JSONObject actor = item
                                                                            .getJSONObject(Sactor);
                                                                    JSONObject object = item
                                                                            .getJSONObject(Sobject);
                                                                    if (item.has(Sid) && actor.has(Sid)
                                                                            && actor.has(SdisplayName)
                                                                            && item.has(Spublished)
                                                                            && object.has(Sreplies)
                                                                            && object.has(SoriginalContent)) {
                                                                        String sid = item.getString(Sid);
                                                                        String esid = actor.getString(Sid);
                                                                        String friend = actor
                                                                                .getString(SdisplayName);
                                                                        String originalContent = object
                                                                                .getString(SoriginalContent);
                                                                        if ((originalContent == null)
                                                                                || (originalContent
                                                                                        .length() == 0)) {
                                                                            originalContent = object
                                                                                    .getString(Scontent);
                                                                        }
                                                                        String photo = null;
                                                                        if (actor.has(Simage)) {
                                                                            JSONObject image = actor
                                                                                    .getJSONObject(Simage);
                                                                            if (image.has(Surl)) {
                                                                                photo = image.getString(Surl);
                                                                            }
                                                                        }
                                                                        long date = parseDate(
                                                                                item.getString(Spublished),
                                                                                GOOGLEPLUS_DATE_FORMAT);
                                                                        int commentCount = 0;
                                                                        JSONObject replies = object
                                                                                .getJSONObject(Sreplies);
                                                                        String notification = null;
                                                                        if (replies.has(StotalItems)) {
                                                                            Log.d(TAG, Sreplies + ":"
                                                                                    + replies.toString());
                                                                            commentCount = replies
                                                                                    .getInt(StotalItems);
                                                                        }
                                                                        if (notification != null) {
                                                                            // new notification
                                                                            addNotification(sid, esid, friend,
                                                                                    originalContent, date,
                                                                                    accountId, notification);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        } catch (UnsupportedEncodingException e) {
                                            Log.e(TAG, e.toString());
                                        } catch (JSONException e) {
                                            Log.e(TAG, e.toString());
                                        }
                                        break;
                                    }
                                }
                                currentNotifications.close();
                            }
                            // remove old notifications
                            getContentResolver().delete(Notifications.getContentUri(SonetNotifications.this),
                                    Notifications.CLEARED + "=1 and " + Notifications.ACCOUNT + "=? and "
                                            + Notifications.CREATED + "<?",
                                    new String[] { Long.toString(accountId),
                                            Long.toString(System.currentTimeMillis() - 86400000) });
                        }
                        account.close();
                        widgets.moveToNext();
                    }
                } else {
                    publishProgress("No notifications have been set up on any accounts.");
                }
                widgets.close();
                return false;
            } else if (arg0[0] == R.id.menu_notifications_clear_all) {
                // clear all notifications
                ContentValues values = new ContentValues();
                values.put(Notifications.CLEARED, 1);
                SonetNotifications.this.getContentResolver()
                        .update(Notifications.getContentUri(SonetNotifications.this), values, null, null);
                return true;
            }
            return false;
        }

        @Override
        protected void onProgressUpdate(String... messages) {
            (Toast.makeText(SonetNotifications.this, messages[0], Toast.LENGTH_LONG)).show();
        }

        @Override
        protected void onPostExecute(Boolean finish) {
            if (loadingDialog.isShowing()) {
                loadingDialog.dismiss();
            }
            if (finish) {
                SonetNotifications.this.finish();
            }
        }

        private void addNotification(String sid, String esid, String friend, String message, long created,
                long accountId, String notification) {
            ContentValues values = new ContentValues();
            values.put(Notifications.SID, sid);
            values.put(Notifications.ESID, esid);
            values.put(Notifications.FRIEND, friend);
            values.put(Notifications.MESSAGE, message);
            values.put(Notifications.CREATED, created);
            values.put(Notifications.ACCOUNT, accountId);
            values.put(Notifications.NOTIFICATION, notification);
            values.put(Notifications.CLEARED, 0);
            values.put(Notifications.UPDATED, created);
            getContentResolver().insert(Notifications.getContentUri(SonetNotifications.this), values);
        }

        private long parseDate(String date, String format) {
            if (date != null) {
                // hack for the literal 'Z'
                if (date.substring(date.length() - 1).equals("Z")) {
                    date = date.substring(0, date.length() - 2) + "+0000";
                }
                Date created = null;
                if (format != null) {
                    if (mSimpleDateFormat == null) {
                        mSimpleDateFormat = new SimpleDateFormat(format, Locale.ENGLISH);
                        // all dates should be GMT/UTC
                        mSimpleDateFormat.setTimeZone(sTimeZone);
                    }
                    try {
                        created = mSimpleDateFormat.parse(date);
                        return created.getTime();
                    } catch (ParseException e) {
                        Log.e(TAG, e.toString());
                    }
                } else {
                    // attempt to parse RSS date
                    if (mSimpleDateFormat != null) {
                        try {
                            created = mSimpleDateFormat.parse(date);
                            return created.getTime();
                        } catch (ParseException e) {
                            Log.e(TAG, e.toString());
                        }
                    }
                    for (String rfc822 : sRFC822) {
                        mSimpleDateFormat = new SimpleDateFormat(rfc822, Locale.ENGLISH);
                        mSimpleDateFormat.setTimeZone(sTimeZone);
                        try {
                            if ((created = mSimpleDateFormat.parse(date)) != null) {
                                return created.getTime();
                            }
                        } catch (ParseException e) {
                            Log.e(TAG, e.toString());
                        }
                    }
                }
            }
            return System.currentTimeMillis();
        }

    };
    loadingDialog.setMessage(getString(R.string.loading));
    loadingDialog.setCancelable(true);
    loadingDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
        @Override
        public void onCancel(DialogInterface dialog) {
            if (!asyncTask.isCancelled())
                asyncTask.cancel(true);
        }
    });
    loadingDialog.setButton(ProgressDialog.BUTTON_NEGATIVE, getString(android.R.string.cancel),
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
    loadingDialog.show();
    asyncTask.execute(item.getItemId());
    return true;
    //      return super.onOptionsItemSelected(item);
}