Example usage for android.app Notification FLAG_AUTO_CANCEL

List of usage examples for android.app Notification FLAG_AUTO_CANCEL

Introduction

In this page you can find the example usage for android.app Notification FLAG_AUTO_CANCEL.

Prototype

int FLAG_AUTO_CANCEL

To view the source code for android.app Notification FLAG_AUTO_CANCEL.

Click Source Link

Document

Bit to be bitwise-ored into the #flags field that should be set if the notification should be canceled when it is clicked by the user.

Usage

From source file:org.mythdroid.util.UpdateService.java

private void notify(String title, String message) {

    NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    Notification notification = new Notification(R.drawable.logo, title, System.currentTimeMillis());

    notification.flags = Notification.FLAG_AUTO_CANCEL;

    notification.setLatestEventInfo(getApplicationContext(), title, message,
            PendingIntent.getActivity(Globals.appContext, 0, new Intent(), 0));

    nm.notify(-1, notification);/*  w  ww . ja v  a  2  s  .c  o  m*/
}

From source file:io.coldstart.android.GCMIntentService.java

private void SendCombinedNotification(String EventCount) {
    Notification notification = new Notification(R.drawable.ic_stat_alert, EventCount + " new SNMP Traps!",
            System.currentTimeMillis());
    notification.flags |= Notification.FLAG_AUTO_CANCEL;
    notification.defaults |= Notification.DEFAULT_VIBRATE;
    notification.flags |= Notification.FLAG_SHOW_LIGHTS;

    notification.ledARGB = 0xffff0000;/*from   w  w  w. j ava2 s.  com*/

    notification.ledOnMS = 300;
    notification.ledOffMS = 1000;

    notification.defaults |= Notification.DEFAULT_SOUND;

    Context context = getApplicationContext();
    Intent notificationIntent = new Intent(this, TrapListActivity.class);
    notificationIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    notificationIntent.putExtra("forceRefresh", true);
    PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
    notification.setLatestEventInfo(context, EventCount + " SNMP Traps", "Click to launch ColdStart.io",
            contentIntent);
    mNM.notify(43523, notification);//NotificationID++ 
}

From source file:com.andrewshu.android.reddit.common.Common.java

public static void newMailNotification(Context context, String mailNotificationStyle, int count) {
    Intent nIntent = new Intent(context, InboxActivity.class);
    PendingIntent contentIntent = PendingIntent.getActivity(context, 0, nIntent, 0);
    Notification notification = new Notification(R.drawable.mail, Constants.HAVE_MAIL_TICKER,
            System.currentTimeMillis());
    if (Constants.PREF_MAIL_NOTIFICATION_STYLE_BIG_ENVELOPE.equals(mailNotificationStyle)) {
        RemoteViews contentView = new RemoteViews(context.getPackageName(), R.layout.big_envelope_notification);
        notification.contentView = contentView;
    } else {/*from   w w w. j av  a 2 s  .c  o  m*/
        notification.setLatestEventInfo(context, Constants.HAVE_MAIL_TITLE,
                count + (count == 1 ? " unread message" : " unread messages"), contentIntent);
    }
    notification.defaults |= Notification.DEFAULT_SOUND;
    notification.flags |= Notification.FLAG_ONLY_ALERT_ONCE | Notification.FLAG_AUTO_CANCEL;
    notification.contentIntent = contentIntent;
    NotificationManager notificationManager = (NotificationManager) context
            .getSystemService(Context.NOTIFICATION_SERVICE);
    notificationManager.notify(Constants.NOTIFICATION_HAVE_MAIL, notification);
}

From source file:org.kaoriha.phonegap.plugins.releasenotification.Notifier.java

private void pollBackground() {
    if (getToken() == null) {
        rescheduleAfterFail();/*from w  w  w  . jav  a2s  . c  om*/
        return;
    }

    ToNextReleasePolling tp = new ToNextReleasePolling();
    tp.poll();
    if (tp.isFailed) {
        Log.d(TAG, "ToNextReleasePolling failed");
        rescheduleAfterFail();
        return;
    }

    CataloguePolling cp = new CataloguePolling();
    cp.poll();
    if (cp.isFailed) {
        Log.d(TAG, "CataloguePolling failed");
        rescheduleAfterFail();
        return;
    }
    if (!cp.isNew) {
        if (tp.toNextRelease == -1) {
            schedule(RESCHEDULE_NEXT_UNKNOWN_SPAN);
        } else {
            schedule(tp.toNextRelease);
        }
        Log.d(TAG, "CataloguePolling not new");
        return;
    }

    String pushMessage;
    if (cp.catalogue.has(CATALOGUE_PUSH_MESSAGE_KEY)) {
        try {
            pushMessage = cp.catalogue.getString(CATALOGUE_PUSH_MESSAGE_KEY);
        } catch (JSONException e) {
            Log.i(TAG, "pollBackground()", e);
            pushMessage = pref.getString(SPKEY_DEFAULT_PUSH_MESSAGE, null);
        }
    } else {
        pushMessage = pref.getString(SPKEY_DEFAULT_PUSH_MESSAGE, null);
    }

    String lastSid;
    try {
        lastSid = getLastSid(cp.catalogue);
        if (lastSid.equals(pref.getString(SPKEY_LAST_SID, null))) {
            schedule(tp.toNextRelease);
        }
    } catch (JSONException e) {
        Log.d(TAG, "bad JSON", e);
        rescheduleAfterFail();
        return;
    }

    int icon = R.drawable.notification;
    Notification n = new Notification(icon, pushMessage, System.currentTimeMillis());
    n.flags = Notification.FLAG_AUTO_CANCEL;
    Intent i = new Intent(ctx, FlowerflowerActivity.class);
    i.setAction(Intent.ACTION_MAIN);
    i.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
    PendingIntent pi = PendingIntent.getActivity(ctx, 0, i, 0);
    n.setLatestEventInfo(ctx.getApplicationContext(), pref.getString(SPKEY_TITLE, null), pushMessage, pi);
    NotificationManager nm = (NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE);
    nm.notify(NOTIFICATION_ID, n);

    pref.edit().putString(SPKEY_LAST_SID, lastSid).putString(SPKEY_LAST_CATALOGUE_ETAG, cp.etag).commit();

    clearFailRepeat();

    schedule(tp.toNextRelease);

    Log.d(TAG, "pollBackground() success");
}

From source file:com.google.appinventor.components.runtime.ProbeBase.java

@SimpleFunction(description = "Create a notication with message to wake up "
        + "another activity when tap on the notification")
public void CreateNotification(String title, String text, boolean enabledSound, boolean enabledVibrate,
        String packageName, String className, String extraKey, String extraVal) throws ClassNotFoundException {

    Intent activityToLaunch = new Intent(Intent.ACTION_MAIN);

    Log.i(TAG, "packageName: " + packageName);
    Log.i(TAG, "className: " + className);

    // for local AI instance, all classes are under the package
    // "appinventor.ai_test"
    // but for those runs on Google AppSpot(AppEngine), the package name will be
    // "appinventor.ai_GoogleAccountUserName"
    // e.g. pakageName = appinventor.ai_HomerSimpson.HelloPurr
    // && className = appinventor.ai_HomerSimpson.HelloPurr.Screen1

    ComponentName component = new ComponentName(packageName, className);
    activityToLaunch.setComponent(component);
    activityToLaunch.putExtra(extraKey, extraVal);

    Log.i(TAG, "we found the class for intent to send into notificaiton");

    activityToLaunch.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);

    mContentIntent = PendingIntent.getActivity(mainUIThreadActivity, 0, activityToLaunch, 0);

    Long currentTimeMillis = System.currentTimeMillis();
    notification = new Notification(R.drawable.stat_notify_chat, "Activate Notification!", currentTimeMillis);

    Log.i(TAG, "After creating notification");
    notification.contentIntent = mContentIntent;
    notification.flags = Notification.FLAG_AUTO_CANCEL;

    // reset the notification
    notification.defaults = 0;/*from  w ww .j av  a  2s .co  m*/

    if (enabledSound)
        notification.defaults |= Notification.DEFAULT_SOUND;

    if (enabledVibrate)
        notification.defaults |= Notification.DEFAULT_VIBRATE;

    notification.setLatestEventInfo(mainUIThreadActivity, (CharSequence) title, (CharSequence) text,
            mContentIntent);
    Log.i(TAG, "after updated notification contents");
    mNM.notify(PROBE_NOTIFICATION_ID, notification);
    Log.i(TAG, "notified");

}

From source file:nl.vanvianen.android.gcm.GCMIntentService.java

@Override
@SuppressWarnings("unchecked")
protected void onMessage(Context context, Intent intent) {
    Log.d(LCAT, "Push notification received");

    boolean isTopic = false;

    HashMap<String, Object> data = new HashMap<String, Object>();
    for (String key : intent.getExtras().keySet()) {
        Object value = intent.getExtras().get(key);
        Log.d(LCAT, "Message key: \"" + key + "\" value: \"" + value + "\"");

        if (key.equals("from") && value instanceof String && ((String) value).startsWith("/topics/")) {
            isTopic = true;/*  www  .  j a  v  a2s  .  c  o m*/
        }

        String eventKey = key.startsWith("data.") ? key.substring(5) : key;
        data.put(eventKey, intent.getExtras().get(key));

        if (value instanceof String && ((String) value).startsWith("{")) {
            Log.d(LCAT, "Parsing JSON string...");
            try {
                JSONObject json = new JSONObject((String) value);

                Iterator<String> keys = json.keys();
                while (keys.hasNext()) {
                    String jKey = keys.next();
                    String jValue = json.getString(jKey);
                    Log.d(LCAT, "JSON key: \"" + jKey + "\" value: \"" + jValue + "\"");

                    data.put(jKey, jValue);
                }
            } catch (JSONException ex) {
                Log.d(LCAT, "JSON error: " + ex.getMessage());
            }
        }
    }

    /* Store data to be retrieved when resuming app as a JSON object, serialized as a String, otherwise
     * Ti.App.Properties.getString(GCMModule.LAST_DATA) doesn't work. */
    JSONObject json = new JSONObject(data);
    TiApplication.getInstance().getAppProperties().setString(GCMModule.LAST_DATA, json.toString());

    /* Get settings from notification object */
    int smallIcon = 0;
    int largeIcon = 0;
    String sound = null;
    boolean vibrate = false;
    boolean insistent = false;
    String group = null;
    boolean localOnly = true;
    int priority = 0;
    boolean bigText = false;
    int notificationId = 1;

    Integer ledOn = null;
    Integer ledOff = null;

    String titleKey = DEFAULT_TITLE_KEY;
    String messageKey = DEFAULT_MESSAGE_KEY;
    String tickerKey = DEFAULT_TICKER_KEY;
    String title = null;
    String message = null;
    String ticker = null;

    boolean backgroundOnly = false;

    Map<String, Object> notificationSettings = new Gson().fromJson(
            TiApplication.getInstance().getAppProperties().getString(GCMModule.NOTIFICATION_SETTINGS, null),
            Map.class);
    if (notificationSettings != null) {
        if (notificationSettings.get("smallIcon") instanceof String) {
            smallIcon = getResource("drawable", (String) notificationSettings.get("smallIcon"));
        } else {
            Log.e(LCAT, "Invalid setting smallIcon, should be String");
        }

        if (notificationSettings.get("largeIcon") instanceof String) {
            largeIcon = getResource("drawable", (String) notificationSettings.get("largeIcon"));
        } else {
            Log.e(LCAT, "Invalid setting largeIcon, should be String");
        }

        if (notificationSettings.get("sound") != null) {
            if (notificationSettings.get("sound") instanceof String) {
                sound = (String) notificationSettings.get("sound");
            } else {
                Log.e(LCAT, "Invalid setting sound, should be String");
            }
        }

        if (notificationSettings.get("vibrate") != null) {
            if (notificationSettings.get("vibrate") instanceof Boolean) {
                vibrate = (Boolean) notificationSettings.get("vibrate");
            } else {
                Log.e(LCAT, "Invalid setting vibrate, should be Boolean");
            }
        }

        if (notificationSettings.get("insistent") != null) {
            if (notificationSettings.get("insistent") instanceof Boolean) {
                insistent = (Boolean) notificationSettings.get("insistent");
            } else {
                Log.e(LCAT, "Invalid setting insistent, should be Boolean");
            }
        }

        if (notificationSettings.get("group") != null) {
            if (notificationSettings.get("group") instanceof String) {
                group = (String) notificationSettings.get("group");
            } else {
                Log.e(LCAT, "Invalid setting group, should be String");
            }
        }

        if (notificationSettings.get("localOnly") != null) {
            if (notificationSettings.get("localOnly") instanceof Boolean) {
                localOnly = (Boolean) notificationSettings.get("localOnly");
            } else {
                Log.e(LCAT, "Invalid setting localOnly, should be Boolean");
            }
        }

        if (notificationSettings.get("priority") != null) {
            if (notificationSettings.get("priority") instanceof Integer) {
                priority = (Integer) notificationSettings.get("priority");
            } else if (notificationSettings.get("priority") instanceof Double) {
                priority = ((Double) notificationSettings.get("priority")).intValue();
            } else {
                Log.e(LCAT,
                        "Invalid setting priority, should be an integer, between PRIORITY_MIN ("
                                + NotificationCompat.PRIORITY_MIN + ") and PRIORITY_MAX ("
                                + NotificationCompat.PRIORITY_MAX + ")");
            }
        }

        if (notificationSettings.get("bigText") != null) {
            if (notificationSettings.get("bigText") instanceof Boolean) {
                bigText = (Boolean) notificationSettings.get("bigText");
            } else {
                Log.e(LCAT, "Invalid setting bigText, should be Boolean");
            }
        }

        if (notificationSettings.get("titleKey") != null) {
            if (notificationSettings.get("titleKey") instanceof String) {
                titleKey = (String) notificationSettings.get("titleKey");
            } else {
                Log.e(LCAT, "Invalid setting titleKey, should be String");
            }
        }

        if (notificationSettings.get("messageKey") != null) {
            if (notificationSettings.get("messageKey") instanceof String) {
                messageKey = (String) notificationSettings.get("messageKey");
            } else {
                Log.e(LCAT, "Invalid setting messageKey, should be String");
            }
        }

        if (notificationSettings.get("tickerKey") != null) {
            if (notificationSettings.get("tickerKey") instanceof String) {
                tickerKey = (String) notificationSettings.get("tickerKey");
            } else {
                Log.e(LCAT, "Invalid setting tickerKey, should be String");
            }
        }

        if (notificationSettings.get("title") != null) {
            if (notificationSettings.get("title") instanceof String) {
                title = (String) notificationSettings.get("title");
            } else {
                Log.e(LCAT, "Invalid setting title, should be String");
            }
        }

        if (notificationSettings.get("message") != null) {
            if (notificationSettings.get("message") instanceof String) {
                message = (String) notificationSettings.get("message");
            } else {
                Log.e(LCAT, "Invalid setting message, should be String");
            }
        }

        if (notificationSettings.get("ticker") != null) {
            if (notificationSettings.get("ticker") instanceof String) {
                ticker = (String) notificationSettings.get("ticker");
            } else {
                Log.e(LCAT, "Invalid setting ticker, should be String");
            }
        }

        if (notificationSettings.get("ledOn") != null) {
            if (notificationSettings.get("ledOn") instanceof Integer) {
                ledOn = (Integer) notificationSettings.get("ledOn");
                if (ledOn < 0) {
                    Log.e(LCAT, "Invalid setting ledOn, should be positive");
                    ledOn = null;
                }
            } else {
                Log.e(LCAT, "Invalid setting ledOn, should be Integer");
            }
        }

        if (notificationSettings.get("ledOff") != null) {
            if (notificationSettings.get("ledOff") instanceof Integer) {
                ledOff = (Integer) notificationSettings.get("ledOff");
                if (ledOff < 0) {
                    Log.e(LCAT, "Invalid setting ledOff, should be positive");
                    ledOff = null;
                }
            } else {
                Log.e(LCAT, "Invalid setting ledOff, should be Integer");
            }
        }

        if (notificationSettings.get("backgroundOnly") != null) {
            if (notificationSettings.get("backgroundOnly") instanceof Boolean) {
                backgroundOnly = (Boolean) notificationSettings.get("backgroundOnly");
            } else {
                Log.e(LCAT, "Invalid setting backgroundOnly, should be Boolean");
            }
        }

        if (notificationSettings.get("notificationId") != null) {
            if (notificationSettings.get("notificationId") instanceof Integer) {
                notificationId = (Integer) notificationSettings.get("notificationId");
            } else {
                Log.e(LCAT, "Invalid setting notificationId, should be Integer");
            }
        }

    } else {
        Log.d(LCAT, "No notification settings found");
    }

    /* If icon not found, default to appicon */
    if (smallIcon == 0) {
        smallIcon = getResource("drawable", "appicon");
    }

    /* If large icon not found, default to icon */
    if (largeIcon == 0) {
        largeIcon = smallIcon;
    }

    /* Create intent to (re)start the app's root activity */
    String pkg = TiApplication.getInstance().getApplicationContext().getPackageName();
    Intent launcherIntent = TiApplication.getInstance().getApplicationContext().getPackageManager()
            .getLaunchIntentForPackage(pkg);
    launcherIntent.setFlags(Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
    launcherIntent.addCategory(Intent.CATEGORY_LAUNCHER);

    /* Grab notification content from data according to provided keys if not already set */
    if (title == null && titleKey != null) {
        title = (String) data.get(titleKey);
    }
    if (message == null && messageKey != null) {
        message = (String) data.get(messageKey);
    }
    if (ticker == null && tickerKey != null) {
        ticker = (String) data.get(tickerKey);
    }

    Log.i(LCAT, "Title: " + title);
    Log.i(LCAT, "Message: " + message);
    Log.i(LCAT, "Ticker: " + ticker);

    /* Check for app state */
    if (GCMModule.getInstance() != null) {
        /* Send data to app */
        if (isTopic) {
            GCMModule.getInstance().sendTopicMessage(data);
        } else {
            GCMModule.getInstance().sendMessage(data);
        }
        /* Do not create notification if backgroundOnly and app is in foreground */
        if (backgroundOnly && GCMModule.getInstance().isInForeground()) {
            Log.d(LCAT, "Notification received in foreground, no need for notification.");
            return;
        }
    }

    if (message == null) {
        Log.d(LCAT,
                "Message received but no 'message' specified in push notification payload, so will make this silent");
    } else {
        Log.d(LCAT, "Creating notification...");

        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), largeIcon);
        if (bitmap == null) {
            Log.d(LCAT, "No large icon found");
        }

        NotificationCompat.Builder builder = new NotificationCompat.Builder(context).setContentTitle(title)
                .setContentText(message).setTicker(ticker)
                .setContentIntent(
                        PendingIntent.getActivity(this, 0, launcherIntent, PendingIntent.FLAG_ONE_SHOT))
                .setSmallIcon(smallIcon).setLargeIcon(bitmap);

        /* Name of group to group similar notifications together, can also be set in the push notification payload */
        if (data.get("group") != null) {
            group = (String) data.get("group");
        }
        if (group != null) {
            builder.setGroup(group);
        }
        Log.i(LCAT, "Group: " + group);

        /* Whether notification should be for this device only or bridged to other devices, can also be set in the push notification payload */
        if (data.get("localOnly") != null) {
            localOnly = Boolean.valueOf((String) data.get("localOnly"));
        }
        builder.setLocalOnly(localOnly);
        Log.i(LCAT, "LocalOnly: " + localOnly);

        /* Specify notification priority, can also be set in the push notification payload */
        if (data.get("priority") != null) {
            priority = Integer.parseInt((String) data.get("priority"));
        }
        if (priority >= NotificationCompat.PRIORITY_MIN && priority <= NotificationCompat.PRIORITY_MAX) {
            builder.setPriority(priority);
            Log.i(LCAT, "Priority: " + priority);
        } else {
            Log.e(LCAT, "Ignored invalid priority " + priority);
        }

        /* Specify whether bigtext should be used, can also be set in the push notification payload */
        if (data.get("bigText") != null) {
            bigText = Boolean.valueOf((String) data.get("bigText"));
        }
        if (bigText) {
            builder.setStyle(new NotificationCompat.BigTextStyle().bigText(message));
        }
        Log.i(LCAT, "bigText: " + bigText);

        Notification notification = builder.build();

        /* Sound, can also be set in the push notification payload */
        if (data.get("sound") != null) {
            Log.d(LCAT, "Sound specified in notification");
            sound = (String) data.get("sound");
        }

        if ("default".equals(sound)) {
            Log.i(LCAT, "Sound: default sound");
            notification.defaults |= Notification.DEFAULT_SOUND;
        } else if (sound != null) {
            Log.i(LCAT, "Sound " + sound);
            notification.sound = Uri.parse("android.resource://" + pkg + "/" + getResource("raw", sound));
        }

        /* Vibrate, can also be set in the push notification payload */
        if (data.get("vibrate") != null) {
            vibrate = Boolean.valueOf((String) data.get("vibrate"));
        }
        if (vibrate) {
            notification.defaults |= Notification.DEFAULT_VIBRATE;
        }
        Log.i(LCAT, "Vibrate: " + vibrate);

        /* Insistent, can also be set in the push notification payload */
        if ("true".equals(data.get("insistent"))) {
            insistent = true;
        }
        if (insistent) {
            notification.flags |= Notification.FLAG_INSISTENT;
        }
        Log.i(LCAT, "Insistent: " + insistent);

        /* notificationId, set in push payload to specify multiple notifications should be shown. If not specified, subsequent notifications "override / overwrite" the older ones */
        if (data.get("notificationId") != null) {
            if (data.get("notificationId") instanceof Integer) {
                notificationId = (Integer) data.get("notificationId");
            } else if (data.get("notificationId") instanceof String) {
                try {
                    notificationId = Integer.parseInt((String) data.get("notificationId"));
                } catch (NumberFormatException ex) {
                    Log.e(LCAT, "Invalid setting notificationId, should be Integer");
                }
            } else {
                Log.e(LCAT, "Invalid setting notificationId, should be Integer");
            }
        }
        Log.i(LCAT, "Notification ID: " + notificationId);

        /* Specify LED flashing */
        if (ledOn != null || ledOff != null) {
            notification.flags |= Notification.FLAG_SHOW_LIGHTS;
            if (ledOn != null) {
                notification.ledOnMS = ledOn;
            }
            if (ledOff != null) {
                notification.ledOffMS = ledOff;
            }
        } else {
            notification.defaults |= Notification.DEFAULT_LIGHTS;
        }

        notification.flags |= Notification.FLAG_AUTO_CANCEL;

        ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).notify(notificationId,
                notification);
    }
}

From source file:com.aniruddhc.acemusic.player.AsyncTasks.AsyncAutoGetAlbumArtTask.java

@Override
protected void onPostExecute(Void arg0) {

    Intent intent = new Intent(mContext, AutoFetchAlbumArtService.class);
    mContext.stopService(intent);/*  w ww  .j  a va 2s .  c  o  m*/

    if (pd.isShowing() && DIALOG_VISIBLE == true) {
        pd.dismiss();
    }

    //Dismiss the notification.
    AutoFetchAlbumArtService.builder
            .setTicker(mContext.getResources().getString(R.string.done_downloading_art));
    AutoFetchAlbumArtService.builder
            .setContentTitle(mContext.getResources().getString(R.string.done_downloading_art));
    AutoFetchAlbumArtService.builder.setSmallIcon(R.drawable.notif_icon);
    AutoFetchAlbumArtService.builder.setContentInfo(null);
    AutoFetchAlbumArtService.builder.setContentText(null);
    AutoFetchAlbumArtService.builder.setProgress(0, 0, false);
    AutoFetchAlbumArtService.notification = AutoFetchAlbumArtService.builder.build();
    AutoFetchAlbumArtService.notification.flags = Notification.FLAG_AUTO_CANCEL;

    NotificationManager notifyManager = (NotificationManager) mContext
            .getSystemService(Context.NOTIFICATION_SERVICE);
    notifyManager.notify(AutoFetchAlbumArtService.NOTIFICATION_ID, AutoFetchAlbumArtService.notification);

    Toast.makeText(mContext, R.string.done_downloading_art, Toast.LENGTH_LONG).show();

    //Rescan for album art.
    //Seting the "RESCAN_ALBUM_ART" flag to true will force MainActivity to rescan the folders.
    sharedPreferences.edit().putBoolean("RESCAN_ALBUM_ART", true).commit();

    //Restart the app.
    final Intent i = mActivity.getBaseContext().getPackageManager()
            .getLaunchIntentForPackage(mActivity.getBaseContext().getPackageName());

    i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    mActivity.startActivity(i);
    mActivity.finish();

}

From source file:info.guardianproject.onionkit.trust.StrongTrustManager.java

private void showCertMessage(String title, String msg, X509Certificate cert, String fingerprint) {

    Intent nIntent = new Intent(mContext, CertDisplayActivity.class);

    nIntent.putExtra("issuer", cert.getIssuerDN().getName());
    nIntent.putExtra("subject", cert.getSubjectDN().getName());

    if (fingerprint != null)
        nIntent.putExtra("fingerprint", fingerprint);

    SimpleDateFormat df = new SimpleDateFormat("dd MMM yyyy HH:mm:ss", Locale.US);
    df.setTimeZone(TimeZone.getTimeZone("UTC"));
    nIntent.putExtra("issued", df.format(cert.getNotBefore()) + " GMT");
    nIntent.putExtra("expires", df.format(cert.getNotAfter()) + " GMT");
    nIntent.putExtra("msg", title + ": " + msg);

    showToolbarNotification(title, msg, DEFAULT_NOTIFY_ID, mAppIcon, Notification.FLAG_AUTO_CANCEL, nIntent);

}

From source file:org.klnusbaum.udj.network.PlaylistSyncService.java

private void alertException(Account account, Intent originalIntent, int titleRes, int contentRes,
        int notificationId) {

    PendingIntent pe = PendingIntent.getService(this, 0, originalIntent, 0);
    Notification notification = new Notification(R.drawable.udjlauncher, "", System.currentTimeMillis());
    notification.setLatestEventInfo(this, getString(titleRes), getString(contentRes), pe);
    notification.flags |= Notification.FLAG_AUTO_CANCEL;

    NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    nm.notify(notificationId, notification);
}

From source file:org.gaeproxy.GAEProxyService.java

/** Called when the activity is closed. */
@Override//from  w  w  w .ja  v a 2 s . c o  m
public void onDestroy() {

    EasyTracker.getTracker().trackEvent("service", "stop", getVersionName(), 0L);

    if (mShutdownReceiver != null) {
        unregisterReceiver(mShutdownReceiver);
        mShutdownReceiver = null;
    }

    statusLock = true;

    stopForegroundCompat(1);

    notifyAlert(getString(R.string.forward_stop), getString(R.string.service_stopped),
            Notification.FLAG_AUTO_CANCEL);

    try {
        if (dnsServer != null)
            dnsServer.close();
    } catch (Exception e) {
        Log.e(TAG, "DNS Server close unexpected");
    }

    new Thread() {
        @Override
        public void run() {

            // Make sure the connection is closed, important here
            onDisconnect();
        }
    }.start();

    // for widget, maybe exception here
    try {
        RemoteViews views = new RemoteViews(getPackageName(), R.layout.gaeproxy_appwidget);
        views.setImageViewResource(R.id.serviceToggle, R.drawable.off);
        AppWidgetManager awm = AppWidgetManager.getInstance(this);
        awm.updateAppWidget(awm.getAppWidgetIds(new ComponentName(this, GAEProxyWidgetProvider.class)), views);
    } catch (Exception ignore) {
        // Nothing
    }

    Editor ed = settings.edit();
    ed.putBoolean("isRunning", false);
    ed.putBoolean("isConnecting", false);
    ed.commit();

    try {
        notificationManager.cancel(0);
    } catch (Exception ignore) {
        // Nothing
    }

    try {
        ProxySettings.resetProxy(this);
    } catch (Exception ignore) {
        // Nothing
    }

    super.onDestroy();

    statusLock = false;

    markServiceStopped();
}