下面列出了怎么用android.support.v4.app.NotificationManagerCompat的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
protected void onHandleIntent(Intent intent) {
if (intent != null) {
final String action = intent.getAction();
if (REFRESH_ITEMS_ACTION.equals(action)) {
Log.d(TAG, "Refresh items START");
Analytics.trackEvent(TAG + " Refresh run items START");
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(NOTIFICATION_ID, buildNotification("AsureRun", "Syncing data...", R.drawable.ic_tracking, null));
handleRefreshItems(notificationManager, false);
} else if (DELETE_DATA_ON_FIRST_START_ACTION.equals(action)) {
Log.d(TAG, "Delete data on first start");
Analytics.trackEvent(TAG + " Delete data on first start");
handleDeleteDataOnFirstStart();
} else if (SEND_ITEM_ACTION.equals(action)) {
Log.d(TAG, "Sending data on server");
handleSendDataOnServer();
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pending);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
mNotificationId = getIntent().getIntExtra("notification_id", 0);
TextView textView = (TextView) findViewById(R.id.notification_id_label);
textView.setText(mNotificationId + "");
Button removeButton = (Button) findViewById(R.id.remove_notification_button);
removeButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
NotificationManagerCompat.from(NotifyResultActivity.this).cancel(mNotificationId);
}
});
}
public MediaNotificationManager(Context context, MediaSessionCompat.Token sessionToken) throws RemoteException {
mContext = context;
mSessionToken = sessionToken;
updateSessionToken();
mNotificationManager = NotificationManagerCompat.from(context);
String pkg = context.getPackageName();
mPauseIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_PAUSE).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mPlayIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_PLAY).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mPreviousIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_PREV).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mNextIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_NEXT).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mStopIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_STOP).setPackage(pkg), PendingIntent.FLAG_CANCEL_CURRENT);
mStopCastIntent = PendingIntent.getBroadcast(context, REQUEST_CODE,
new Intent(ACTION_STOP_CASTING).setPackage(pkg),
PendingIntent.FLAG_CANCEL_CURRENT);
// Cancel all notifications to handle the case where the Service was killed and
// restarted by the system.
mNotificationManager.cancelAll();
}
void simpleNoti() {
//create the intent to launch the notiactivity, then the pentingintent.
Intent viewIntent = new Intent(this, NotiActivity.class);
viewIntent.putExtra("NotiID", "Notification ID is " + notificationID);
PendingIntent viewPendingIntent =
PendingIntent.getActivity(this, 0, viewIntent, 0);
//Now create the notification. We must use the NotificationCompat or it will not work on the wearable.
NotificationCompat.Builder notificationBuilder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle("Simple Noti")
.setContentText("This is a simple notification")
.setContentIntent(viewPendingIntent);
// Get an instance of the NotificationManager service
NotificationManagerCompat notificationManager =
NotificationManagerCompat.from(this);
// Build the notification and issues it with notification manager.
notificationManager.notify(notificationID, notificationBuilder.build());
notificationID++;
}
private AlarmDatabaseAdapter.AlarmItemTaskListener onShowState(final Context context)
{
return new AlarmDatabaseAdapter.AlarmItemTaskListener()
{
@Override
public void onFinished(Boolean result, AlarmClockItem item)
{
Log.d(TAG, "State Saved (onShow)");
if (item.type == AlarmClockItem.AlarmType.ALARM)
{
if (!NotificationManagerCompat.from(context).areNotificationsEnabled())
{
// when notifications are disabled, fallback to directly starting the fullscreen activity
startActivity(getFullscreenIntent(context, item.getUri()));
} else {
showAlarmPlayingToast(getApplicationContext(), item);
context.sendBroadcast(getFullscreenBroadcast(item.getUri())); // update fullscreen activity
}
}
}
};
}
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
super.onMessageReceived(remoteMessage);
setNotificationChannel();
Uri uri = Uri.parse(getString(R.string.app_latest_release_url));
Intent intent = new Intent(Intent.ACTION_VIEW, uri);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(getString(R.string.app_update_notification_title))
.setPriority(NotificationCompat.PRIORITY_LOW)
.setContentIntent(pendingIntent)
.setAutoCancel(true);
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(33, builder.build());
}
PlayerNotification(PlayerService service)
{
this.mService = service;
mNotificationManager = NotificationManagerCompat.from(service);
mPlayAction = new NotificationCompat.Action(R.drawable.play_arrow, mService.getString(R.string.play),
MediaButtonReceiver.buildMediaButtonPendingIntent(mService, PlaybackStateCompat.ACTION_PLAY));
mPauseAction = new NotificationCompat.Action(R.drawable.pause_notif, mService.getString(R.string.pause),
MediaButtonReceiver.buildMediaButtonPendingIntent(mService, PlaybackStateCompat.ACTION_PAUSE));
mNextAction = new NotificationCompat.Action(R.drawable.next_arrow_notif, mService.getString(R.string.next),
MediaButtonReceiver.buildMediaButtonPendingIntent(mService, PlaybackStateCompat.ACTION_SKIP_TO_NEXT));
mPrevAction = new NotificationCompat.Action(R.drawable.prev_arrow_notif, mService.getString(R.string.prev),
MediaButtonReceiver.buildMediaButtonPendingIntent(mService, PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS));
mNotificationManager.cancelAll();
}
@Override
public void onReceive(Context context, Intent intent) {
// Get the lifeform details from the intent.
String type = intent.getStringExtra(EXTRA_LIFEFORM_NAME);
double lat = intent.getDoubleExtra(EXTRA_LATITUDE, Double.NaN);
double lng = intent.getDoubleExtra(EXTRA_LONGITUDE, Double.NaN);
if (type.equals(FACE_HUGGER)) {
NotificationManagerCompat notificationManager =
NotificationManagerCompat.from(context);
NotificationCompat.Builder builder =
new NotificationCompat.Builder(context);
builder.setSmallIcon(R.drawable.ic_alien)
.setContentTitle("Face Hugger Detected")
.setContentText(Double.isNaN(lat) || Double.isNaN(lng) ?
"Location Unknown" :
"Located at " + lat + "," + lng);
notificationManager.notify(NOTIFICATION_ID, builder.build());
}
}
/**
* Create a notification
*
* @param context The application context
* @param title Notification title
* @param content Notification content.
*/
public static void createNotification(final Context context, final String title,
final String content, int id) {
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
NotificationCompat.Builder builder =
new NotificationCompat.Builder(context).setContentTitle(title)
.setStyle(new NotificationCompat.BigTextStyle().bigText(content))
.setColor(ContextCompat.getColor(context, R.color.main_theme))
.extend(new NotificationCompat.WearableExtender()
.setHintShowBackgroundOnly(true)).setContentText(content)
.setAutoCancel(true).setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
.setContentIntent(PendingIntent.getActivity(context, 0, new Intent(), 0))
.setSmallIcon(R.drawable.ic_stat_kuas_ap);
builder.setVibrate(vibrationPattern);
builder.setLights(Color.GREEN, 800, 800);
builder.setDefaults(Notification.DEFAULT_SOUND);
notificationManager.notify(id, builder.build());
}
@Nullable
public JSONArray schedule(PluginCall call, List<LocalNotification> localNotifications) {
JSONArray ids = new JSONArray();
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
boolean notificationsEnabled = notificationManager.areNotificationsEnabled();
if (!notificationsEnabled) {
call.error("Notifications not enabled on this device");
return null;
}
for (LocalNotification localNotification : localNotifications) {
Integer id = localNotification.getId();
if (localNotification.getId() == null) {
call.error("LocalNotification missing identifier");
return null;
}
dismissVisibleNotification(id);
cancelTimerForNotification(id);
buildNotification(notificationManager, localNotification, call);
ids.put(id);
}
return ids;
}
@Override
protected void onHandleIntent(Intent intent) {
// TODO(smcgruer): Skip if today is already done.
NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
.setAutoCancel(true)
.setContentTitle("Three Things Today")
.setContentText("Record what happened today!")
.setDefaults(NotificationCompat.DEFAULT_ALL)
.setSmallIcon(R.drawable.ic_stat_name);
Intent notifyIntent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(
this, 0, notifyIntent, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(pendingIntent);
Notification notificationCompat = builder.build();
NotificationManagerCompat managerCompat = NotificationManagerCompat.from(this);
managerCompat.notify(NOTIFICATION_ID, notificationCompat);
}
@Override
public boolean onStartJob(JobParameters params) {
context = this;
notificationManagerCompat = NotificationManagerCompat.from(context);
preferences = PreferenceManager.getDefaultSharedPreferences(context);
if (!preferences.getBoolean(AutoCleanSettingsActivity.PREF_AUTO_CLEAN, false)) return false;
sendNotification();
cleanUp();
sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, Uri.parse("file://" + Environment.getExternalStorageDirectory())));
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
Log.v(MyUtil.PACKAGE_NAME, getString(R.string.toast_auto_clean, deletedFileCount));
Toast.makeText(
context,
getString(R.string.toast_auto_clean, deletedFileCount),
Toast.LENGTH_SHORT
).show();
notificationManagerCompat.cancel(NOTIFICATION_JOB_ID);
}
}, 3000);
return true;
}
@Override
public void onReceive(Context c, Intent i) {
Log.i(TAG, "received result: " + getResultCode());
if (getResultCode() != Activity.RESULT_OK) {
// A foreground activity cancelled the broadcast
return;
}
int requestCode = i.getIntExtra(PollService.REQUEST_CODE, 0);
Notification notification = (Notification)
i.getParcelableExtra(PollService.NOTIFICATION);
NotificationManagerCompat notificationManager =
NotificationManagerCompat.from(c);
notificationManager.notify(requestCode, notification);
}
@Override
protected void onReceive(final Context context, Intent intent,
@Nullable final MasterSecret masterSecret)
{
if (!CLEAR_ACTION.equals(intent.getAction()))
return;
final long[] threadIds = intent.getLongArrayExtra(THREAD_IDS_EXTRA);
if (threadIds != null) {
NotificationManagerCompat.from(context).cancel(intent.getIntExtra(NOTIFICATION_ID_EXTRA, -1));
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
for (long threadId : threadIds) {
Log.w(TAG, "Marking as read: " + threadId);
DatabaseFactory.getThreadDatabase(context).setRead(threadId);
DatabaseFactory.getThreadDatabase(context).setLastSeen(threadId);
}
MessageNotifier.updateNotification(context, masterSecret);
return null;
}
}.execute();
}
}
private void setupTimer( long duration ) {
NotificationManagerCompat notificationManager = NotificationManagerCompat.from( this );
notificationManager.cancel( 1 );
notificationManager.notify( 1, buildNotification( duration ) );
registerAlarmManager(duration);
finish();
}
/**
* Displays a notification.
* @param platformTag The notification tag, see
* {@link NotificationManager#notify(String, int, Notification)}.
* @param platformId The notification id, see
* {@link NotificationManager#notify(String, int, Notification)}.
* @param notification The notification to be displayed, constructed by the provider.
* @param channelName The name of the notification channel that the notification should be
* displayed on. This method gets or creates a channel from the name and
* modifies the notification to use that channel.
* @return Whether the notification was successfully displayed (the channel/app may be blocked
* by the user).
*/
protected boolean notifyNotificationWithChannel(String platformTag, int platformId,
Notification notification, String channelName) {
ensureOnCreateCalled();
if (!NotificationManagerCompat.from(this).areNotificationsEnabled()) return false;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = channelNameToId(channelName);
// Create the notification channel, (no-op if already created).
mNotificationManager.createNotificationChannel(new NotificationChannel(channelId,
channelName, NotificationManager.IMPORTANCE_DEFAULT));
// Check that the channel is enabled.
if (mNotificationManager.getNotificationChannel(channelId).getImportance() ==
NotificationManager.IMPORTANCE_NONE) {
return false;
}
// Set our notification to have that channel.
Notification.Builder builder = Notification.Builder.recoverBuilder(this, notification);
builder.setChannelId(channelId);
notification = builder.build();
}
mNotificationManager.notify(platformTag, platformId, notification);
return true;
}
public void disableContext(Context context) {
NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(context);
notificationManagerCompat.cancel(1);
if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.O) {
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.deleteNotificationChannel("channel_01");
}
Process.killProcess(Process.myPid());
}
protected void startRinging() {
if(currentState==STATE_WAITING_INCOMING){
return;
}
if(USE_CONNECTION_SERVICE && systemCallConnection!=null)
systemCallConnection.setRinging();
if (BuildVars.LOGS_ENABLED) {
FileLog.d("starting ringing for call " + call.id);
}
dispatchStateChanged(STATE_WAITING_INCOMING);
startRingtoneAndVibration(user.id);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !((KeyguardManager) getSystemService(KEYGUARD_SERVICE)).inKeyguardRestrictedInputMode() && NotificationManagerCompat.from(this).areNotificationsEnabled()) {
showIncomingNotification(ContactsController.formatName(user.first_name, user.last_name), null, user, null, 0, VoIPActivity.class);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Showing incoming call notification");
}
} else {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Starting incall activity for incoming call");
}
try {
PendingIntent.getActivity(VoIPService.this, 12345, new Intent(VoIPService.this, VoIPActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK), 0).send();
} catch (Exception x) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error starting incall activity", x);
}
}
if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
showNotification();
}
}
}
public void onUIForegroundStateChanged(boolean isForeground) {
if (currentState == STATE_WAITING_INCOMING) {
if (isForeground) {
stopForeground(true);
} else {
if (!((KeyguardManager) getSystemService(KEYGUARD_SERVICE)).inKeyguardRestrictedInputMode()) {
if(NotificationManagerCompat.from(this).areNotificationsEnabled())
showIncomingNotification(ContactsController.formatName(user.first_name, user.last_name), null, user, null, 0, VoIPActivity.class);
else
declineIncomingCall(DISCARD_REASON_LINE_BUSY, null);
} else {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public void run() {
Intent intent = new Intent(VoIPService.this, VoIPActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP);
try {
PendingIntent.getActivity(VoIPService.this, 0, intent, 0).send();
} catch (PendingIntent.CanceledException e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("error restarting activity", e);
}
declineIncomingCall(DISCARD_REASON_LINE_BUSY, null);
}
if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
showNotification();
}
}
}, 500);
}
}
}
}
private void raise_vehicle_notification(String msg) {
final NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
builder.setContentText(msg);
builder.setSmallIcon(R.drawable.ic_launcher);
if (VehicleMode.shouldPlaySound()) {
setInternalPrefsLong(VEHICLE_MODE_LAST_ALERT, JoH.tsl());
builder.setSound(Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + getPackageName() + "/" + R.raw.labbed_musical_chime));
}
builder.setContentTitle(getString(R.string.app_name) + " " + "Vehicle mode");
cancel_vehicle_notification();
NotificationManagerCompat.from(this).notify(VEHICLE_NOTIFICATION_ID, builder.build());
}
/**
* Create a notification manager for the specified service
* @param service service to manage
*/
TransferNotificationManager(Service service) {
mService = service;
mSettings = new Settings(service);
mNotificationManager = (NotificationManager) mService.getSystemService(
Service.NOTIFICATION_SERVICE);
// Android O requires the notification channels to be created
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
createChannel(SERVICE_CHANNEL_ID, R.string.channel_service_name,
NotificationManager.IMPORTANCE_MIN, false);
createChannel(TRANSFER_CHANNEL_ID, R.string.channel_transfer_name,
NotificationManager.IMPORTANCE_LOW, false);
createChannel(NOTIFICATION_CHANNEL_ID, R.string.channel_notification_name,
NotificationManager.IMPORTANCE_DEFAULT, true);
}
// Create the intent for opening the main activity
mIntent = PendingIntent.getActivity(
mService,
0,
new Intent(mService, TransferActivity.class),
0
);
// Create the builder
mBuilder = createBuilder(SERVICE_CHANNEL_ID)
.setContentIntent(mIntent)
.setContentTitle(mService.getString(R.string.service_transfer_server_title))
.setSmallIcon(R.drawable.ic_stat_transfer);
// Set the priority
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
mBuilder.setPriority(NotificationManagerCompat.IMPORTANCE_MIN);
} else {
mBuilder.setPriority(NotificationCompat.PRIORITY_MIN);
}
}
public static void showNotification(Context context, int id, String title, String content, Uri uri, Action action) {
if (NotificationManagerCompat.from(context).areNotificationsEnabled()) {
Intent intent = new Intent(context, MainActivity.class);
intent.putExtra("conversion", action.getInstanceUuid());
PendingIntent openApplicationWithAction = PendingIntent.getActivity(
context,
0,
intent,
PendingIntent.FLAG_UPDATE_CURRENT);
Notification notification = new NotificationCompat.Builder(context, OREO_NOTIFICATION_CHANNEL)
.setContentIntent(openApplicationWithAction)
.setContentTitle(title)
.setContentText(content)
.setSmallIcon(R.drawable.ic_beacon)
.setAutoCancel(true)
.setShowWhen(true)
.build();
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(id, notification);
SensorbergSdk.notifyConversionStatus(context, action.getInstanceUuid(), Conversion.NOTIFICATION_SHOWN);
} else {
SensorbergSdk.notifyConversionStatus(context, action.getInstanceUuid(), Conversion.NOTIFICATION_DISABLED);
}
}
public static void showGroupNotifications(Context context, String group) {
Notification first = new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle(context.getString(R.string.page1_title))
.setContentText(context.getString(R.string.page1_text))
.setGroup(group)
.build();
Notification second = new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle(context.getString(R.string.page2_title))
.setContentText(context.getString(R.string.page2_text))
.setGroup(group)
.build();
Notification summary = new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle(context.getString(R.string.summary_title))
.setContentText(context.getString(R.string.summary_text))
.setGroup(group)
.setGroupSummary(true)
.build();
NotificationManagerCompat.from(context).notify(getNewID(), first);
NotificationManagerCompat.from(context).notify(getNewID(), second);
NotificationManagerCompat.from(context).notify(getNewID(), summary);
}
/**
* 是否已经授予通知相关权限
*
* @param context，上下文对象
* @return
*/
private boolean isNotificationListenerServiceEnabled(Context context) {
Set<String> packageNames = NotificationManagerCompat.getEnabledListenerPackages(context);
if (packageNames.contains(context.getPackageName())) {
return true;
}
return false;
}
void showNotification(int id, String text, Context context){
NotificationCompat.Builder builder =
new NotificationCompat.Builder(context, ReminderScheduler.CHANNEL_ID)
.setSmallIcon(R.drawable.ic_alarm_black_24dp)
.setContentTitle("Reminder")
.setContentText(text + "!")
.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
.setPriority(NotificationCompat.PRIORITY_HIGH);
//.setAutoCancel(true);
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
notificationManager.notify(id, builder.build());
}
private void bgOngoingNotification(final BgGraphBuilder bgGraphBuilder) {
mHandler.post(new Runnable() {
@Override
public void run() {
NotificationManagerCompat
.from(mContext)
.notify(ongoingNotificationId, createOngoingNotification(bgGraphBuilder, mContext));
if (iconBitmap != null)
iconBitmap.recycle();
if (notifiationBitmap != null)
notifiationBitmap.recycle();
}
});
}
private void updateNotification(FileItem downloadItem, String content, String[] bigTextArray) {
StringBuilder bigText = new StringBuilder();
for (int i = 0; i < bigTextArray.length; i++) {
bigText.append(bigTextArray[i]);
if (i < 4) {
bigText.append("\n");
}
}
Intent foregroundIntent = new Intent(this, DownloadService.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, foregroundIntent, 0);
Intent cancelIntent = new Intent(this, DownloadCancelAction.class);
PendingIntent cancelPendingIntent = PendingIntent.getBroadcast(this, 0, cancelIntent, 0);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(android.R.drawable.stat_sys_download)
.setContentTitle(downloadItem.getName())
.setContentText(content)
.setPriority(NotificationCompat.PRIORITY_LOW)
.setContentIntent(pendingIntent)
.setStyle(new NotificationCompat.BigTextStyle().bigText(bigText.toString()))
.addAction(R.drawable.ic_cancel_download, getString(R.string.cancel), cancelPendingIntent);
NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(this);
notificationManagerCompat.notify(PERSISTENT_NOTIFICATION_ID, builder.build());
}
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "onReceive called");
int conversationId = intent.getIntExtra(CONVERSATION_ID, -1);
if (conversationId != -1) {
Log.d(TAG, "Conversation " + conversationId + " was read");
NotificationManagerCompat.from(context).cancel(conversationId);
}
}
private void createSummaryNotificationForFinished() {
Notification summaryNotification =
new NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle(getString(R.string.download_complete))
//set content text to support devices running API level < 24
.setContentText(getString(R.string.download_complete))
.setSmallIcon(android.R.drawable.stat_sys_download_done)
.setGroup(DOWNLOAD_FINISHED_GROUP)
.setGroupSummary(true)
.setAutoCancel(true)
.build();
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(DOWNLOAD_FINISHED_NOTIFICATION_ID, summaryNotification);
}
private void showDownloadFailedNotification(int notificationId, String contentText) {
createSummaryNotificationForFailed();
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(android.R.drawable.stat_sys_warning)
.setContentTitle(getString(R.string.download_failed))
.setContentText(contentText)
.setGroup(DOWNLOAD_FAILED_GROUP)
.setPriority(NotificationCompat.PRIORITY_LOW);
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(notificationId, builder.build());
}