Example usage for android.app NotificationChannel setImportance

List of usage examples for android.app NotificationChannel setImportance

Introduction

In this page you can find the example usage for android.app NotificationChannel setImportance.

Prototype

public void setImportance(@Importance int importance) 

Source Link

Document

Sets the level of interruption of this notification channel.

Usage

From source file:org.mozilla.focus.session.SessionNotificationService.java

public void createNotificationChannelIfNeeded() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
        // Notification channels are only available on Android O or higher.
        return;//  w ww .j  a va2  s  .  c om
    }

    final NotificationManager notificationManager = getSystemService(NotificationManager.class);
    if (notificationManager == null) {
        return;
    }

    final String notificationChannelName = getString(R.string.notification_browsing_session_channel_name);
    final String notificationChannelDescription = getString(
            R.string.notification_browsing_session_channel_description, getString(R.string.app_name));

    final NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
            notificationChannelName, NotificationManager.IMPORTANCE_MIN);
    channel.setImportance(NotificationManager.IMPORTANCE_LOW);
    channel.setDescription(notificationChannelDescription);
    channel.enableLights(false);
    channel.enableVibration(false);
    channel.setShowBadge(true);

    notificationManager.createNotificationChannel(channel);
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void appointmentNotification() {
    Appointment[] appointments = calendarDB.getNotificationAppointments();
    Log.d(TAG, "AppointmentNotifications: amount of appointments that should be shown: " + appointments.length);
    String previousAppointment = configUtil.getString("previous_appointment");
    if (appointments.length >= 1) {
        Appointment appointment = appointments[0];
        if (!mGson.toJson(appointment).equals(previousAppointment) && isCandidate(appointment)) {
            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
            mBuilder.setSmallIcon(R.drawable.ic_appointment);

            if (appointment.startDate != null) {
                String time = DateUtils.formatDate(appointment.startDate, "HH:mm");
                mBuilder.setContentTitle("Volgende afspraak (" + time + ")");
            } else {
                mBuilder.setContentTitle("Volgende afspraak:");
            }/*from ww w.  ja va2 s  . com*/
            mBuilder.setContentText(appointment.description + " in " + appointment.location);
            mBuilder.setAutoCancel(true);
            mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);

            Intent resultIntent = new Intent(context, AppointmentActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
            stackBuilder.addParentStack(AppointmentActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);

            NotificationManager mNotificationManager = (NotificationManager) context
                    .getSystemService(Context.NOTIFICATION_SERVICE);

            if (Build.VERSION.SDK_INT >= 26) {
                String channelId = APPOINTMENT_NOTIFICATIONCHANNEL_ID;
                CharSequence channelName = APPOINTMENT_NOTIFICATIONCHANNEL_ID;
                int importance = NotificationManager.IMPORTANCE_LOW;
                NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                        importance);
                notificationChannel.enableLights(false);
                notificationChannel.enableVibration(false);
                notificationChannel.setImportance(NotificationManager.IMPORTANCE_LOW);
                mNotificationManager.createNotificationChannel(notificationChannel);
                mBuilder.setChannelId(APPOINTMENT_NOTIFICATIONCHANNEL_ID);
            }
            mNotificationManager.notify(APPOINTMENT_NOTIFICATION_ID, mBuilder.build());

            previousAppointment = mGson.toJson(appointment);
            configUtil.setString("previous_appointment", previousAppointment);
        }
    } else {
        NotificationManager notifManager = (NotificationManager) context
                .getSystemService(Context.NOTIFICATION_SERVICE);
        notifManager.cancel(APPOINTMENT_NOTIFICATION_ID);
    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void newHomeworkNotification() {
    Appointment[] newhomework = homeworkDB.getAppointmentsWithHomework();
    ArrayList<Appointment> homeworkList = new ArrayList<>();
    for (Appointment appointment : newhomework) {
        if (homeworkDB.isModified(appointment, true))
            homeworkList.add(appointment);
    }/* w w  w. j a va 2  s  . c o m*/
    Log.d(TAG, "newHomeworkNotification: Amount of new homework: " + homeworkList.size());
    if (homeworkList.size() > 0) {
        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
        mBuilder.setSmallIcon(R.drawable.ic_new_homework);

        String content = "Je hebt nieuw of aangepast huiswerk voor:";
        for (Appointment appointment : homeworkList) {
            content = content + "\n" + appointment.description
                    + DateUtils.formatDate(appointment.startDate, "' ('dd MMM')'");
        }

        mBuilder.setContentTitle("Nieuw huiswerk");
        mBuilder.setStyle(new NotificationCompat.BigTextStyle(mBuilder).bigText(content));
        mBuilder.setContentText(content);
        mBuilder.setAutoCancel(true);
        mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
        mBuilder.setDefaults(Notification.DEFAULT_ALL);

        Intent resultIntent = new Intent(context, HomeworkActivity.class);
        TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
        stackBuilder.addParentStack(ScheduleChangeActivity.class);
        stackBuilder.addNextIntent(resultIntent);
        PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
        mBuilder.setContentIntent(resultPendingIntent);

        NotificationManager mNotificationManager = (NotificationManager) context
                .getSystemService(Context.NOTIFICATION_SERVICE);
        if (Build.VERSION.SDK_INT >= 26) {
            String channelId = NEW_HOMEWORK_NOTIFICATIONCHANNEL_ID;
            CharSequence channelName = NEW_HOMEWORK_NOTIFICATIONCHANNEL_ID;
            int importance = NotificationManager.IMPORTANCE_LOW;
            NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                    importance);
            notificationChannel.enableLights(true);
            notificationChannel.setLightColor(Color.RED);
            notificationChannel.enableVibration(true);
            notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
            notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
            mNotificationManager.createNotificationChannel(notificationChannel);
            mBuilder.setChannelId(NEW_HOMEWORK_NOTIFICATIONCHANNEL_ID);
        }
        mNotificationManager.notify(NEW_HOMEWORK_NOTIFICATION_ID, mBuilder.build());
    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void nextAppointmentChangedNotification() {
    Appointment[] appointments = scheduleChangeDB.getNotificationAppointments();
    String previousChangedAppointment = configUtil.getString("previous_changed_appointment");
    if (appointments.length > 0) {
        Appointment appointment = appointments[0];
        if (!appointment.startDateString.equals(previousChangedAppointment)) {
            String content;/*from  www. j  av a 2s.  c  o  m*/
            if (appointment.description != null && !appointment.description.equalsIgnoreCase("null")) {
                content = appointment.description;
            } else {
                content = "De les is uitgevallen!";
            }

            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
            mBuilder.setSmallIcon(R.drawable.ic_schedule_change);

            mBuilder.setContentTitle("Let op! De volgende les is gewijzigd!");
            mBuilder.setContentText(content);
            mBuilder.setAutoCancel(true);
            mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
            mBuilder.setDefaults(Notification.DEFAULT_ALL);

            Intent resultIntent = new Intent(context, ScheduleChangeActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
            stackBuilder.addParentStack(ScheduleChangeActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);

            NotificationManager mNotificationManager = (NotificationManager) context
                    .getSystemService(Context.NOTIFICATION_SERVICE);
            if (Build.VERSION.SDK_INT >= 26) {
                String channelId = NEXT_APPOINTMENT_CHANGED_NOTIFICATIONCHANNEL_ID;
                CharSequence channelName = NEXT_APPOINTMENT_CHANGED_NOTIFICATIONCHANNEL_ID;
                int importance = NotificationManager.IMPORTANCE_LOW;
                NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                        importance);
                notificationChannel.enableLights(true);
                notificationChannel.setLightColor(Color.RED);
                notificationChannel.enableVibration(true);
                notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
                notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
                mNotificationManager.createNotificationChannel(notificationChannel);
                mBuilder.setChannelId(NEXT_APPOINTMENT_CHANGED_NOTIFICATIONCHANNEL_ID);
            }
            mNotificationManager.notify(NEXT_APPOINTMENT_CHANGED_NOTIFICATION_ID, mBuilder.build());

            configUtil.setString("previous_changed_appointment", appointment.startDateString);
        }
    } else {
        NotificationManager notifManager = (NotificationManager) context
                .getSystemService(Context.NOTIFICATION_SERVICE);
        notifManager.cancel(NEXT_APPOINTMENT_CHANGED_NOTIFICATION_ID);
    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void newScheduleChangeNotification() {
    if (allowDataTransfer()) {
        Magister magister = GlobalAccount.MAGISTER;
        if (magister == null || magister.isExpired()) {
            Log.d(TAG, "ScheduleChangeNotification: No valid Magister");
        } else {//from   w  w w . j a  va  2  s . c o m

            AppointmentHandler appointmentHandler = new AppointmentHandler(magister);
            Appointment[] appointments;
            try {
                Log.d(TAG, "ScheduleChangeNotification: Requesting schedule changes....");
                appointments = appointmentHandler.getScheduleChanges(DateUtils.getToday(),
                        DateUtils.addDays(DateUtils.getToday(), 3));
            } catch (IOException | AssertionError e) {
                Log.d(TAG, "ScheduleChangeNotification: Error while requesting schedule changes");
                e.printStackTrace();
                return;
            }

            Boolean newChanges = false;
            if (appointments == null || appointments.length < 1) {
                return;
            } else {
                Log.d(TAG, "ScheduleChangeNotification: Checking for new changes....");
                for (Appointment appointment : appointments) {
                    if (!scheduleChangeDB.isInDatabase(appointment)) {
                        newChanges = true;
                    }
                }
                scheduleChangeDB.addItems(appointments);
            }

            if (newChanges) {
                NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
                mBuilder.setSmallIcon(R.drawable.ic_schedule_change);

                mBuilder.setContentTitle("Nieuwe roosterijziging(en)!");
                mBuilder.setContentText("Tik om te bekijken");
                mBuilder.setAutoCancel(true);
                mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
                mBuilder.setDefaults(Notification.DEFAULT_ALL);

                Intent resultIntent = new Intent(context, ScheduleChangeActivity.class);
                TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
                stackBuilder.addParentStack(ScheduleChangeActivity.class);
                stackBuilder.addNextIntent(resultIntent);
                PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                mBuilder.setContentIntent(resultPendingIntent);

                NotificationManager mNotificationManager = (NotificationManager) context
                        .getSystemService(Context.NOTIFICATION_SERVICE);
                if (Build.VERSION.SDK_INT >= 26) {
                    String channelId = NEW_SCHEDULE_CHANGE_NOTIFICATIONCHANNEL_ID;
                    CharSequence channelName = NEW_SCHEDULE_CHANGE_NOTIFICATIONCHANNEL_ID;
                    int importance = NotificationManager.IMPORTANCE_LOW;
                    NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                            importance);
                    notificationChannel.enableLights(true);
                    notificationChannel.setLightColor(Color.RED);
                    notificationChannel.enableVibration(true);
                    notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
                    notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
                    mNotificationManager.createNotificationChannel(notificationChannel);
                    mBuilder.setChannelId(NEW_SCHEDULE_CHANGE_NOTIFICATIONCHANNEL_ID);
                }
                mNotificationManager.notify(NEW_SCHEDULE_CHANGE_NOTIFICATION_ID, mBuilder.build());
            }
        }

    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void unFinishedHomeworkNotification() {
    String lastCheck = configUtil.getString("last_unfinished_homework_check");
    if (lastCheck.equals(""))
        lastCheck = DateUtils.formatDate(DateUtils.addDays(new Date(), -1), "yyyyMMdd");

    Date lastCheckDate = DateUtils.parseDate(lastCheck, "yyyyMMdd");
    Date now = DateUtils.parseDate(DateUtils.formatDate(new Date(), "yyyyMMdd"), "yyyyMMdd");
    Integer hours = configUtil.getInteger("unfinished_homework_hour");
    Integer minutes = configUtil.getInteger("unfinished_homework_minute");
    if (lastCheckDate.before(now)) {
        lastCheckDate = DateUtils.addHours(lastCheckDate, 24 + hours);
        lastCheckDate = DateUtils.addMinutes(lastCheckDate, minutes);
        if (new Date().after(lastCheckDate)) {
            Appointment[] appointments = calendarDB.getUnfinishedAppointments(DateUtils.addDays(now, 1));

            if (appointments.length > 0) {

                NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
                mBuilder.setSmallIcon(R.drawable.ic_unfinished_homework);
                mBuilder.setContentTitle("Huiswerk waarschuwing");

                if (appointments.length == 1) {
                    mBuilder.setContentText(appointments[0].description);
                } else {
                    String content = "Je hebt je huiswerk voor de volgende lessen van morgen nog niet afgerond:";
                    for (Appointment appointment : appointments) {
                        String string = appointment.description;
                        if (content.length() > 1) {
                            content = content + "\n" + string;
                        } else {
                            content = string;
                        }//ww w  .  j a  v  a  2 s .c  o m
                    }
                    mBuilder.setStyle(new NotificationCompat.BigTextStyle(mBuilder).bigText(content));
                    mBuilder.setContentText(content);
                }
                mBuilder.setAutoCancel(true);
                mBuilder.setVisibility(NotificationCompat.VISIBILITY_PRIVATE);
                mBuilder.setDefaults(Notification.DEFAULT_ALL);
                mBuilder.setLights(Color.RED, 300, 200);

                Intent resultIntent = new Intent(context, HomeworkActivity.class);
                TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
                stackBuilder.addParentStack(NewGradeActivity.class);
                stackBuilder.addNextIntent(resultIntent);
                PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                mBuilder.setContentIntent(resultPendingIntent);

                NotificationManager mNotificationManager = (NotificationManager) context
                        .getSystemService(Context.NOTIFICATION_SERVICE);
                if (Build.VERSION.SDK_INT >= 26) {
                    String channelId = UNFINISHED_HOMEWORK_NOTIFICATIONCHANNEL_ID;
                    CharSequence channelName = UNFINISHED_HOMEWORK_NOTIFICATIONCHANNEL_ID;
                    int importance = NotificationManager.IMPORTANCE_LOW;
                    NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                            importance);
                    notificationChannel.enableLights(true);
                    notificationChannel.setLightColor(Color.RED);
                    notificationChannel.enableVibration(true);
                    notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
                    notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
                    mNotificationManager.createNotificationChannel(notificationChannel);
                    mBuilder.setChannelId(UNFINISHED_HOMEWORK_NOTIFICATIONCHANNEL_ID);
                }
                mNotificationManager.notify(UNFINISHED_HOMEWORK_NOTIFICATION_ID, mBuilder.build());
            }

            configUtil.setString("last_unfinished_homework_check",
                    DateUtils.formatDate(new Date(), "yyyyMMdd"));
        }
    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void manageSession(final User user, final School school) {
    if (allowDataTransfer()) {
        if (GlobalAccount.MAGISTER == null) {
            if (configUtil.getInteger("failed_auth") >= 2) {
                Log.w(TAG, "run: Warning! 2 Failed authentications, aborting for user's safety!");
                if (configUtil.getBoolean("shown_failed_login_notification"))
                    return;
                configUtil.setBoolean("shown_failed_login_notification", true);
                NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
                mBuilder.setSmallIcon(R.drawable.ic_error);

                Intent resultIntent = new Intent(context, DashboardActivity.class);
                TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
                stackBuilder.addParentStack(DashboardActivity.class);
                stackBuilder.addNextIntent(resultIntent);
                PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                        PendingIntent.FLAG_UPDATE_CURRENT);

                mBuilder.setContentIntent(resultPendingIntent);
                mBuilder.setContentTitle(context.getString(R.string.dialog_login_failed_title));
                mBuilder.setContentText(context.getString(R.string.msg_fix_login));
                mBuilder.setAutoCancel(true);
                mBuilder.setSound(null);
                mBuilder.setVisibility(NotificationCompat.VISIBILITY_PRIVATE);

                NotificationManager mNotificationManager = (NotificationManager) context
                        .getSystemService(Context.NOTIFICATION_SERVICE);
                if (Build.VERSION.SDK_INT >= 26) {
                    String channelId = LOGIN_FAILED_CHANNEL_ID;
                    CharSequence channelName = LOGIN_FAILED_CHANNEL_ID;
                    int importance = NotificationManager.IMPORTANCE_LOW;
                    NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                            importance);
                    notificationChannel.enableLights(true);
                    notificationChannel.setLightColor(Color.RED);
                    notificationChannel.enableVibration(true);
                    notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
                    notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
                    mNotificationManager.createNotificationChannel(notificationChannel);
                    mBuilder.setChannelId(LOGIN_FAILED_CHANNEL_ID);
                }/*from   w  w  w  . ja  va  2  s  .c  o m*/
                mNotificationManager.notify(LOGIN_FAILED_ID, mBuilder.build());
            } else {
                configUtil.setBoolean("shown_failed_login_notification", false);
                try {
                    Log.d(TAG, "SessionManager: initiating session");
                    GlobalAccount.MAGISTER = Magister.login(school, user.username, user.password);
                    configUtil.setInteger("failed_auth", 0);
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (ParseException e) {
                    e.printStackTrace();
                } catch (InvalidParameterException e) {
                    int fails = configUtil.getInteger("failed_auth");
                    fails++;
                    configUtil.setInteger("failed_auth", fails);
                    Log.w(TAG, "SessionManager: Amount of failed Authentications: " + fails);
                }
            }
        } else if (GlobalAccount.MAGISTER.isExpired()) {
            configUtil.setBoolean("shown_failed_login_notification", false);
            try {
                GlobalAccount.MAGISTER.login();
                Log.d(TAG, "SessionManager: refreshing session");
                configUtil.setInteger("failed_auth", 0);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InvalidParameterException e) {
                e.printStackTrace();
                int fails = configUtil.getInteger("failed_auth");
                fails++;
                configUtil.setInteger("failed_auth", fails);
                Log.w(TAG, "SessionManager: Amount of failed Authentications: " + fails);
            }
        } else {
            Log.d(TAG, "manageSession: Session still valid");
        }
    }
}

From source file:com.z3r0byte.magistify.Services.BackgroundService.java

private void newGradeNotification() {
    if (!allowDataTransfer()) {
        return;/*from w ww .  jav  a  2 s.  c  om*/
    }
    Magister magister = GlobalAccount.MAGISTER;
    if (magister == null || magister.isExpired()) {
        Log.e(TAG, "New Grade Notification: Invalid magister");
    } else {

        GradeHandler gradeHandler = new GradeHandler(magister);
        Grade[] gradeArray;
        List<Grade> gradeList = new ArrayList<Grade>();
        try {
            gradeArray = gradeHandler.getRecentGrades();
            gradesdb.addGrades(gradeArray);
            Collections.reverse(Arrays.asList(gradeArray));

            //For testing purposes:
            /*Grade sampleGrade = new Grade();
            sampleGrade.isSufficient = false;
            sampleGrade.grade = "2.3";
            sampleGrade.subject = new SubSubject();
            sampleGrade.subject.name = "Latijn";
                    
            Grade sampleGrade2 = new Grade();
            sampleGrade2.isSufficient = true;
            sampleGrade2.grade = "6.5";
            sampleGrade2.subject = new SubSubject();
            sampleGrade2.subject.name = "Nederlands";
                    
            gradeArray = new Grade[2];
            gradeArray[0] = sampleGrade;
            gradeArray[1] = sampleGrade2;*/
            for (Grade grade : gradeArray) {
                if (!gradesdb.hasBeenSeen(grade, false)
                        && (grade.isSufficient || !configUtil.getBoolean("pass_grades_only"))) {
                    gradeList.add(grade);
                }
            }

        } catch (IOException | AssertionError | NullPointerException e) {
            e.printStackTrace();
            return;
        }
        String GradesNotification = mGson.toJson(gradeList);
        if (gradeList.size() > 0
                && !configUtil.getString("lastGradesNotification").equals(GradesNotification)) {

            Log.d(TAG, "New Grade Notification: Some grades to show: " + gradeList.size());

            NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context);
            mBuilder.setSmallIcon(R.drawable.ic_grade_notification);

            if (gradeList.size() == 1) {
                Grade grade = gradeList.get(0);
                if (grade.description != null) {
                    mBuilder.setContentTitle(
                            "Nieuw cijfer voor " + grade.subject.name + " - " + grade.description);
                } else {
                    mBuilder.setContentTitle("Nieuw cijfer voor " + grade.subject.name);
                }
                //mBuilder.setStyle(new NotificationCompat.BigTextStyle(mBuilder).bigText())
                mBuilder.setContentText("Een " + grade.grade);
            } else {
                CharSequence content = "";
                for (Grade grade : gradeList) {
                    CharSequence string;
                    if (grade.description != null) {
                        string = grade.subject.name + " - " + grade.description + ": "
                                + Html.fromHtml("<strong>" + grade.grade + "</strong>");
                    } else {
                        string = grade.subject.name + ", een " + grade.grade;
                    }
                    if (content.length() > 1) {
                        content = content + "\n" + string;
                    } else {
                        content = string;
                    }
                }
                mBuilder.setContentTitle("Nieuwe cijfers voor:");
                mBuilder.setStyle(new NotificationCompat.BigTextStyle(mBuilder).bigText(content));
                mBuilder.setContentText(content);
            }
            mBuilder.setAutoCancel(true);
            mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
            mBuilder.setDefaults(Notification.DEFAULT_ALL);
            mBuilder.setLights(Color.LTGRAY, 300, 200);

            Intent resultIntent = new Intent(context, NewGradeActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
            stackBuilder.addParentStack(NewGradeActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);

            NotificationManager mNotificationManager = (NotificationManager) context
                    .getSystemService(Context.NOTIFICATION_SERVICE);

            if (Build.VERSION.SDK_INT >= 26) {
                String channelId = NEW_GRADE_NOTIFICATIONCHANNEL_ID;
                CharSequence channelName = NEW_GRADE_NOTIFICATIONCHANNEL_ID;
                int importance = NotificationManager.IMPORTANCE_LOW;
                NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName,
                        importance);
                notificationChannel.enableLights(true);
                notificationChannel.setLightColor(Color.RED);
                notificationChannel.enableVibration(true);
                notificationChannel.setImportance(NotificationManager.IMPORTANCE_DEFAULT);
                notificationChannel.setVibrationPattern(new long[] { 100, 200, 150 });
                mNotificationManager.createNotificationChannel(notificationChannel);
                mBuilder.setChannelId(NEW_GRADE_NOTIFICATIONCHANNEL_ID);
            }

            mNotificationManager.notify(NEW_GRADE_NOTIFICATION_ID, mBuilder.build());

            configUtil.setString("lastGradesNotification", GradesNotification);
        } else {
            Log.w(TAG, "New Grade Notification: No grades!");
        }
    }
}