Example usage for android.os AsyncTask AsyncTask

List of usage examples for android.os AsyncTask AsyncTask

Introduction

In this page you can find the example usage for android.os AsyncTask AsyncTask.

Prototype

public AsyncTask() 

Source Link

Document

Creates a new asynchronous task.

Usage

From source file:de.tudarmstadt.dvs.myhealthassistant.myhealthhub.services.SystemMonitor.java

private void sendNotification(JSONArray t) {
    new AsyncTask<JSONArray, Void, Void>() {
        @Override//  www  . j a v  a 2  s . co  m
        protected Void doInBackground(JSONArray... params) {
            JSONArray message = params[0];

            try {

                // Building Parameters
                List<NameValuePair> pairs = new ArrayList<NameValuePair>();
                pairs.add(new BasicNameValuePair("message", message.toString()));
                pairs.add(new BasicNameValuePair("phone", phoneNr));

                JSONObject json = jParser.makeHttpRequest(getString(R.string.send_url), "POST", pairs);

                // check log cat for response
                if (json != null) {
                    String response = json.getString("message");
                    Log.e(SystemMonitor.class.getSimpleName(), "Post Response: " + response);
                } else
                    Log.e(SystemMonitor.class.getSimpleName(), "No Response!!");
            } catch (JSONException e) {
                Log.e(SystemMonitor.class.getSimpleName(), "JSONException: " + e.getMessage());
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void v) {
        }
    }.execute(t, null, null);
}

From source file:org.deviceconnect.android.deviceplugin.sonycamera.utils.DConnectUtil.java

/**
 * ???System Profile??./*from  w  w w . jav  a2 s . c o  m*/
 * 
 * @param deviceId ?ID
 * @param listener 
 */
public static void asyncSystemProfile(final String deviceId, final DConnectMessageHandler listener) {
    AsyncTask<Void, Void, DConnectMessage> task = new AsyncTask<Void, Void, DConnectMessage>() {
        @Override
        protected DConnectMessage doInBackground(final Void... params) {
            try {
                DConnectClient client = new HttpDConnectClient();
                HttpGet request = new HttpGet(SYSTEM_PROFILE_URI + "?deviceId=" + deviceId);
                HttpResponse response = client.execute(request);
                return (new HttpMessageFactory()).newDConnectMessage(response);
            } catch (IOException e) {
                return new DConnectResponseMessage(DConnectMessage.RESULT_ERROR);
            }
        }

        @Override
        protected void onPostExecute(final DConnectMessage message) {
            if (listener != null) {
                listener.handleMessage(message);
            }
        }
    };
    task.execute();
}

From source file:com.herokuapp.pushdemoandroid.DemoActivity.java

public void onClick(final View view) {

    if (view == findViewById(R.id.send)) {
        new AsyncTask<Void, Void, String>() {
            @Override/*  ww  w  . j  a  v a 2  s  . com*/
            protected String doInBackground(Void... params) {
                String msg = "";
                try {
                    Bundle data = new Bundle();
                    data.putString("my_message", "Hello World");
                    data.putString("my_action", "com.google.android.gcm.demo.app.ECHO_NOW");
                    String id = Integer.toString(msgId.incrementAndGet());
                    gcm.send(CommonUtilities.SENDER_ID + "@gcm.googleapis.com", id, data);
                    msg = "Sent message";
                } catch (IOException ex) {
                    msg = "Error :" + ex.getMessage();
                }
                return msg;
            }

            @Override
            protected void onPostExecute(String msg) {
            }
        }.execute(null, null, null);
    } else if (view == findViewById(R.id.clear)) {
    }
}

From source file:com.piusvelte.sonet.core.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//from w  w w  . java 2s .c om
        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(TWITTER_KEY, 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(IDENTICA_KEY, 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(MYSPACE_KEY, 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(LINKEDIN_KEY, 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", GOOGLE_CLIENTID));
                                        httpParams.add(
                                                new BasicNameValuePair("client_secret", GOOGLE_CLIENTSECRET));
                                        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);
}

From source file:ti.modules.titanium.geolocation.GeolocationModule.java

@Override
public boolean handleMessage(final Message msg) {
    if (msg.what == MSG_LOOKUP) {
        AsyncTask<Object, Void, Integer> task = new AsyncTask<Object, Void, Integer>() {
            @Override/*from   w ww  .j a va  2  s. c o m*/
            protected Integer doInBackground(Object... args) {
                try {
                    String url = (String) args[0];
                    String direction = (String) args[1];
                    KrollCallback callback = (KrollCallback) args[2];

                    if (DBG) {
                        Log.d(LCAT, "GEO URL: " + url);
                    }
                    HttpGet httpGet = new HttpGet(url);

                    HttpParams httpParams = new BasicHttpParams();
                    HttpConnectionParams.setConnectionTimeout(httpParams, 5000); // TODO use property
                    // HttpConnectionParams.setSoTimeout(httpParams, 15000);
                    // //TODO use property
                    HttpClient client = new DefaultHttpClient(httpParams);

                    ResponseHandler<String> responseHandler = new BasicResponseHandler();
                    client.getParams().setBooleanParameter("http.protocol.expect-continue", false);

                    String response = client.execute(httpGet, responseHandler);

                    if (DBG) {
                        Log.i(LCAT, "Received Geo: " + response);
                    }
                    KrollDict event = null;
                    if (response != null) {
                        try {
                            JSONObject r = new JSONObject(response);
                            if (r.getBoolean("success")) {
                                if (direction.equals("r")) {
                                    event = buildReverseResponse(r);
                                } else {
                                    event = buildForwardResponse(r);
                                }
                            } else {
                                event = new KrollDict();
                                KrollDict err = new KrollDict();
                                String errorCode = r.getString("errorcode");
                                err.put("message", "Unable to resolve message: Code (" + errorCode + ")");
                                err.put("code", errorCode);
                                event.put("error", err);
                            }
                        } catch (JSONException e) {
                            Log.e(LCAT, "Error converting geo response to JSONObject: " + e.getMessage(), e);
                        }
                    }

                    if (event != null) {
                        event.put("source", this);
                        callback.callAsync(event);
                    }
                } catch (Throwable t) {
                    Log.e(LCAT, "Error retrieving geocode information: " + t.getMessage(), t);
                }

                return -1;
            }

        };

        task.execute(msg.getData().getString("url"), msg.getData().getString("direction"), msg.obj);

        return true;
    }

    return super.handleMessage(msg);
}

From source file:com.netdoers.utils.ApplicationLoader.java

private void registerInBackground() {
    AsyncTask<String, String, Boolean> task = new AsyncTask<String, String, Boolean>() {
        @Override/*from w  w  w .  j av a 2  s  .  c  o m*/
        protected Boolean doInBackground(String... objects) {
            if (gcm == null) {
                gcm = GoogleCloudMessaging.getInstance(applicationContext);
            }
            int count = 0;
            while (count < 100) {
                try {
                    count++;
                    regid = gcm.register(BuildVars.GCM_SENDER_ID);
                    storeRegistrationId(applicationContext, regid);
                    if (!ApplicationLoader.getSharedPreferences().getBoolean("isRegisteredToServer", false)) {
                        sendRegistrationIdToBackend();
                    } else {
                        Log.i("AndroidToServer", "Already registered to server");
                    }
                    return true;
                } catch (Exception e) {
                    FileLog.e("tmessages", e);
                }
                try {
                    if (count % 20 == 0) {
                        Thread.sleep(60000 * 30);
                    } else {
                        Thread.sleep(5000);
                    }
                } catch (InterruptedException e) {
                    FileLog.e("tmessages", e);
                }
            }
            return false;
        }
    };

    if (android.os.Build.VERSION.SDK_INT >= 11) {
        task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null, null, null);
    } else {
        task.execute(null, null, null);
    }
}

From source file:com.mozilla.simplepush.simplepushdemoapp.MainActivity.java

/** Register with GCM in the background, returning the result back to the UI thread
        //from  w ww  .  ja  v a  2  s . co  m
 */
private void registerInBackground() {
    new AsyncTask<Void, Void, String>() {
        @Override
        protected String doInBackground(Void... params) {
            String msg = "";
            try {
                if (gcm == null) {
                    gcm = GoogleCloudMessaging.getInstance(context);
                }
                regid = gcm.register(SENDER_ID);
                Log.d(TAG, SENDER_ID + " registering " + regid);
                msg = "Device registered, registration ID = " + regid;
                // Send the new registration number to SimplePush server
                sendRegistrationIdToBackend(regid);
                // And remember it into the preferences.
                storeRegistrationId(context, regid);
            } catch (IOException ex) {
                msg = "Error: registerInBackground: doInBackground: " + ex.getMessage();
                Log.e(TAG, msg);
            } catch (Exception x) {
                Log.e(TAG, "Unknown exception " + x.toString());
            }
            return msg;
        }

        //Yay! A thing happened. We should let folks know about the thing.
        @Override
        protected void onPostExecute(String msg) {
            mDisplay.append(msg + "\n");
        }
    }.execute(null, null, null);
}

From source file:com.odoo.addons.sale.models.SaleOrder.java

public void cancelOrder(final Sales.Type type, final ODataRow quotation,
        final OnOperationSuccessListener listener) {
    new AsyncTask<Void, Void, Void>() {
        private ProgressDialog dialog;

        @Override/*from   www .  j a  va  2  s.  c  o m*/
        protected void onPreExecute() {
            super.onPreExecute();
            dialog = new ProgressDialog(mContext);
            dialog.setTitle(R.string.title_please_wait);
            dialog.setMessage(OResource.string(mContext, R.string.title_working));
            dialog.setCancelable(false);
            dialog.show();
        }

        @Override
        protected Void doInBackground(Void... params) {
            try {
                if (type == Sales.Type.SaleOrder) {
                    OArguments args = new OArguments();
                    args.add(new JSONArray().put(quotation.getInt("id")));
                    args.add(new JSONObject());
                    getServerDataHelper().callMethod("action_cancel", args);
                } else {
                    getServerDataHelper().executeWorkFlow(quotation.getInt("id"), "cancel");
                }
                OValues values = new OValues();
                values.put("state", "cancel");
                values.put("state_title", getStateTitle(values));
                values.put("_is_dirty", "false");
                update(quotation.getInt(OColumn.ROW_ID), values);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            dialog.dismiss();
            if (listener != null) {
                listener.OnSuccess();
            }
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            dialog.dismiss();
            if (listener != null) {
                listener.OnCancelled();
            }
        }
    }.execute();
}

From source file:eu.operando.proxy.OperandoProxyStatus.java

private void installCert()
        throws RootCertificateException, GeneralSecurityException, OperatorCreationException, IOException {

    new AsyncTask<Void, Void, Certificate>() {
        Exception error;//from   w  w w  . jav  a2s. co m
        ProgressDialog dialog;

        @Override
        protected void onPreExecute() {
            dialog = ProgressDialog.show(MainProxyActivity.this, null, "Generating SSL certificate...");
            dialog.setCancelable(false);
        }

        @Override
        protected Certificate doInBackground(Void... params) {
            try {
                Certificate cert = BouncyCastleSslEngineSource
                        .initializeKeyStoreStatic(mainContext.getAuthority());
                return cert;
            } catch (Exception e) {
                error = e;
                return null;
            }
        }

        @Override
        protected void onPostExecute(Certificate certificate) {
            dialog.dismiss();

            if (certificate != null) {
                Intent intent = KeyChain.createInstallIntent();
                try {
                    intent.putExtra(KeyChain.EXTRA_CERTIFICATE, certificate.getEncoded());
                } catch (CertificateEncodingException e) {
                    e.printStackTrace();
                }
                intent.putExtra(KeyChain.EXTRA_NAME, mainContext.getAuthority().commonName());
                startActivityForResult(intent, 1);
            } else {
                Toast.makeText(MainProxyActivity.this,
                        "Failed to load certificates, exiting: " + error.getMessage(), Toast.LENGTH_LONG)
                        .show();
                finish();
            }
        }
    }.execute();

}

From source file:com.almarsoft.GroundhogReader.ComposeActivity.java

private void postMessage() {

    AsyncTask<Void, Void, Void> messagePosterTask = new AsyncTask<Void, Void, Void>() {

        String mPostingErrorMessage = null;

        @Override/*  w w w  .  j  a  va2s .  c  o  m*/
        protected Void doInBackground(Void... arg0) {
            MessagePosterLib poster = new MessagePosterLib(mCurrentGroup, mEdit_Groups.getText().toString(),
                    mEdit_Body.getText().toString(), mEdit_Subject.getText().toString(), mReferences,
                    mMessageID, ComposeActivity.this);

            try {
                poster.postMessage();
            }

            catch (SocketException e) {
                e.printStackTrace();
                mPostingErrorMessage = e.toString();
            }

            catch (EncoderException e) {
                e.printStackTrace();
                mPostingErrorMessage = e.toString();
            }

            catch (IOException e) {
                e.printStackTrace();
                mPostingErrorMessage = e.toString();
            }

            catch (ServerAuthException e) {
                e.printStackTrace();
                mPostingErrorMessage = e.toString();
            }

            catch (UsenetReaderException e) {
                e.printStackTrace();
                mPostingErrorMessage = e.toString();
            }

            return null;
        }

        protected void onPostExecute(Void arg0) {
            try {
                dismissDialog(ID_DIALOG_POSTING);
            } catch (IllegalArgumentException e) {
            }

            if (mPostingErrorMessage != null) {
                new AlertDialog.Builder(ComposeActivity.this).setTitle(getString(R.string.error_posting))
                        .setMessage(mPostingErrorMessage).setNeutralButton(getString(R.string.close), null)
                        .show();
                mPostingErrorMessage = null;
            } else {
                setResult(RESULT_OK);
                finish();
            }
        }

    }; // End messagePosterTask

    String groups = mEdit_Groups.getText().toString();

    if (groups == null || groups.trim().length() == 0) {
        new AlertDialog.Builder(ComposeActivity.this).setTitle(getString(R.string.empty_groups))
                .setMessage(getString(R.string.must_select_group)).setNeutralButton("Close", null).show();
    } else {
        showDialog(ID_DIALOG_POSTING);
        messagePosterTask.execute();
    }
}