如何显示通知即使手机处于打盹或应用程序处于应用程序待机模式？

Question

I am building an app that should remind the user about upcoming events that they set (basically a reminder). The issue i'm running into is pushing notifications to the user's phone (only on API 26+) when the app has not been utilized for a while (about 15 minutes or more); notifications are not displayed at all.

I read up on this and realized that App Standby and Doze mode may prevent my app from pushing such notifications; my notifications are received as intended by the user on phones running API 25 and below. To solve this I tried using AlarmManager.setExactAndAllowWhileIdle() but the issue persists.

class TaskNotifications {
    private AlarmManager alarmManager;
    private Context c;

    TaskNotifications(Context context) {
        this.c = context;
        this.alarmManager = (AlarmManager) c.getSystemService(Context.ALARM_SERVICE);
    }

    void setReminder(Context context, Task task) {
        if (VERSION.SDK_INT < Build.VERSION_CODES.O) {
            long reminderMilliseconds = task.getReminderMilliseconds();
            if (reminderMilliseconds > Calendar.getInstance().getTimeInMillis() && !task.isDone()) {
                Intent intent = new Intent(context, NotificationReceiver.class);
                intent.putExtra("ID", task.getID());
                intent.putExtra("TITLE", task.getTitle());
                intent.putExtra("DETAILS", task.getDetails());

                PendingIntent pendingIntent = PendingIntent.getBroadcast(context, task.getID(), intent, PendingIntent.FLAG_UPDATE_CURRENT);
                if (VERSION.SDK_INT >= 23) {
                    this.alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, reminderMilliseconds, pendingIntent);
                } else
                    this.alarmManager.setExact(AlarmManager.RTC_WAKEUP, reminderMilliseconds, pendingIntent);
            }
        }
    }

    void cancelReminder(Task task) {
        if (VERSION.SDK_INT < Build.VERSION_CODES.O) {
            this.alarmManager.cancel(PendingIntent.getBroadcast(this.c, task.getID(),
                    new Intent(this.c, NotificationReceiver.class), PendingIntent.FLAG_CANCEL_CURRENT));
        }
    }
}

public class NotificationReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        Intent startIntent = new Intent(context, NotificationJobIntentService.class);

        startIntent.putExtra("ID", intent.getIntExtra("ID", -1));
        startIntent.putExtra("TITLE", intent.getStringExtra("TITLE"));
        startIntent.putExtra("DETAILS", intent.getStringExtra("DETAILS"));

        JobIntentService.enqueueWork(context, NotificationJobIntentService.class, intent.getIntExtra("ID", -1), startIntent);
    }
}

public class NotificationJobIntentService extends JobIntentService {
    private String CHANNEL_ID = getResources().getString(R.string.channel_name);

    protected void onHandleWork(@NonNull Intent intent) {
        createNotificationChannel(NotificationJobIntentService.this);

        int NOTIFICATION_ID = intent.getIntExtra("ID", -1);
        String GROUP = "NOTIFICATION_GROUP";

        String title = intent.getStringExtra("TITLE");
        if (title.isEmpty())
            title = getResources().getString(R.string.no_title);

        String details = intent.getStringExtra("DETAILS");
        if (details.isEmpty())
            details = getResources().getString(R.string.no_details);

        Intent openAppIntent = new Intent(NotificationJobIntentService.this, MainActivity.class);
        TaskStackBuilder create = TaskStackBuilder.create(this);
        create.addNextIntentWithParentStack(openAppIntent);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(NotificationJobIntentService.this, this.CHANNEL_ID)
                .setContentTitle(title)
                .setContentText(details)
                .setSmallIcon(R.drawable.baseline_alarm_black_18)
                .setPriority(NotificationCompat.PRIORITY_MAX)
                .setContentIntent(create.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT))
                .setCategory(NotificationCompat.CATEGORY_ALARM)
                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
                .setGroup(GROUP)
                .setAutoCancel(true)
                .setColor(Color.argb(100, 0, 87, 75))
                .setVibrate(new long[]{1000, 1000})
                .setLights(Color.GREEN, PathInterpolatorCompat.MAX_NUM_POINTS, PathInterpolatorCompat.MAX_NUM_POINTS)
                .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM));

        NotificationManagerCompat.from(this).notify(NOTIFICATION_ID, builder.build());
    }

    private void createNotificationChannel(Context context) {
        if (VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            CharSequence string = context.getString(R.string.channel_name);
            String description = context.getString(R.string.channel_description);
            NotificationChannel notificationChannel = new NotificationChannel(this.CHANNEL_ID, string, NotificationManager.IMPORTANCE_HIGH);
            notificationChannel.setDescription(description);
            notificationChannel.enableLights(true);
            notificationChannel.setLightColor(Color.GREEN);
            notificationChannel.enableVibration(true);
            notificationChannel.setVibrationPattern(new long[]{1000, 1000});
            (context.getSystemService(NotificationManager.class)).createNotificationChannel(notificationChannel);
        }
    }
}

Is there a reliable way for me to send exact/somewhat exact notifications to my users' phones running API 26+? Or is there an error in my code that I did not notice?

Answer 1

I was unable to make the notification system work on API 26+ devices, however, I used the Android Calendar Provider Reminders to add the event to the users calendar and then set a reminder through the default calendar...not what I originally wanted, but it is a band-aid solution.

If anybody can still solve the problem as intended, please let me know.

Code below:

if (task.getEventID() > 0) {
                //Remove existing events for this task
                ContentResolver cr = c.getContentResolver();
                int iNumRowsDeleted;
                Uri eventUri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, task.getEventID());
                iNumRowsDeleted = cr.delete(eventUri, null, null);
                Log.i("removeEvent()", "Deleted " + iNumRowsDeleted + " calendar entry.");
            }
            try {
                //Add an event
                ContentResolver cr = context.getContentResolver();
                ContentValues values = new ContentValues();
                values.put(CalendarContract.Events.DTSTART, task.getCal().getTimeInMillis());
                values.put(CalendarContract.Events.DTEND, task.getCal().getTimeInMillis()+60*60*1000);//Each task a duration of 60 minutes
                values.put(CalendarContract.Events.TITLE, task.getTitle() + " - " + task.getDetails());
                values.put(CalendarContract.Events.CALENDAR_ID, getPrimaryCalendar());
                values.put(CalendarContract.Events.EVENT_TIMEZONE, Calendar.getInstance().getTimeZone().getID());

                Uri uri = cr.insert(CalendarContract.Events.CONTENT_URI, values);

                // Save the eventId into the Task object for possible future delete.
                task.setEventID(Integer.parseInt(uri.getLastPathSegment()));
                Log.i("addEvent()","The event id is " + task.getEventID());

                // Add a reminder
                ContentValues valuesR = new ContentValues();
                valuesR.put(CalendarContract.Reminders.MINUTES, (task.getCal().getTimeInMillis() - reminderMilliseconds)/(1000*60));
                valuesR.put(CalendarContract.Reminders.EVENT_ID, task.getEventID());
                valuesR.put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT); /*The alarm method, as set on the server. METHOD_DEFAULT, METHOD_ALERT, METHOD_EMAIL, METHOD_SMS and METHOD_ALARM are possible values; the device will only process METHOD_DEFAULT and METHOD_ALERT reminders (the other types are simply stored so we can send the same reminder info back to the server when we make changes).*/
                Uri uriR = cr.insert(CalendarContract.Reminders.CONTENT_URI, valuesR);
                Cursor c = CalendarContract.Reminders.query(cr, task.getEventID(), new String[]{CalendarContract.Reminders.MINUTES});
                if (c.moveToFirst()) {
                    Log.i("setReminder()",task.toString());
                    Log.i("setReminder()","calendar has reminder at " + c.getInt(c.getColumnIndex(CalendarContract.Reminders.MINUTES)));
                }
                c.close();
            } catch (Exception e) {
                e.printStackTrace();
            }