关闭或不使用应用程序时未显示通知

时间:2020-06-30 09:31:36

标签: android kotlin notifications

我正在使用AlarmManager在打开应用程序并停留在MainActivity的确切时间显示通知,但是显示了通知,但是当我的应用程序关闭时,该通知没有显示,我的应用程序中没有错误

NotificationReceiver.kt

private const val ID_NOTIFICATION_SHOLAT_DZUHUR = 10
private const val ID_NOTIFICATION_SHOLAT_ASHAR = 11
private const val ID_NOTIFICATION_SHOLAT_MAGHRIB = 12
private const val ID_NOTIFICATION_SHOLAT_ISYA = 13
private const val ID_NOTIFICATION_SHOLAT_NISFLU_LAIL = 14
private const val ID_NOTIFICATION_SHOLAT_SHUBUH = 15
private const val ID_NOTIFICATION_SHOLAT_SYURUQ = 16
private const val ID_NOTIFICATION_SHOLAT_DHUHA = 17
private const val NOTIFICATION_TYPE = "type"
private const val TYPE_SHOLAT_DZUHUR = "Waktu Sholat Dzuhur"
private const val TYPE_SHOLAT_ASHAR = "Waktu Sholat Ashar"
private const val TYPE_SHOLAT_MAGHRIB = "Waktu Sholat Maghrib"
private const val TYPE_SHOLAT_ISYA = "Waktu Sholat Isya"
private const val TYPE_SHOLAT_NISFU_LAIL = "Waktu Sholat Nisfu Lail"
private const val TYPE_SHOLAT_SHUBUH = "Waktu Sholat Shubuh"
private const val TYPE_SHOLAT_SYURUQ= "Waktu Sholat Syuruq"
private const val TYPE_SHOLAT_DHUHA= "Waktu Sholat Dhuha"

    class NotificationReceiver : BroadcastReceiver() {
    
        override fun onReceive(context: Context?, intent: Intent?) {
            val type = intent!!.getStringExtra(NOTIFICATION_TYPE)
            if(type == TYPE_SHOLAT_DZUHUR || type == TYPE_SHOLAT_ASHAR || type == TYPE_SHOLAT_MAGHRIB
                || type == TYPE_SHOLAT_ISYA || type == TYPE_SHOLAT_NISFU_LAIL || type == TYPE_SHOLAT_SHUBUH
                || type == TYPE_SHOLAT_SYURUQ || type == TYPE_SHOLAT_DHUHA
            ){
                Log.d("notif", "NYALA NIH")
                showNotificationWaktuSholat(context, type)
            }
        }
    
        private fun getReminderTime(type : String, context: Context) : Calendar{
            val localData = LocalData(context)
            val falak = FalakLib()
            var hour = 0
            var minute = 0
            var splitData: List<String>
            val calendar = Calendar.getInstance()
            val waktuDzuhur = falak.DHHMS(localData.iZuhur, "HH:MM")
            val waktuAShar = falak.DHHMS(localData.iAshar, "HH:MM")
            val waktuMaghrib = falak.DHHMS(localData.iMagrib, "HH:MM")
            val waktuIsya = falak.DHHMS(localData.iIsya, "HH:MM")
            val waktuNisfuLail = falak.DHHMS(localData.iNisfuLail, "HH:MM")
            val waktuShubuh = falak.DHHMS(localData.iSubuh, "HH:MM")
            val waktuSyuruk = falak.DHHMS(localData.iSyuruk, "HH:MM")
            val waktuDhuha = falak.DHHMS(localData.iDuha, "HH:MM")
            if(type == TYPE_SHOLAT_DZUHUR){
                splitData = waktuDzuhur.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
                Log.d("JAM NYA DZUHUR","$hour:$minute")
            }
            if(type == TYPE_SHOLAT_ASHAR){
                splitData = waktuAShar.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
                Log.d("JAM NYA ASHAR","$hour:$minute")
            }
            if(type == TYPE_SHOLAT_MAGHRIB){
                splitData = waktuMaghrib.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
            if(type == TYPE_SHOLAT_ISYA){
                splitData = waktuIsya.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
            if(type == TYPE_SHOLAT_NISFU_LAIL){
                splitData = waktuNisfuLail.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
            if(type == TYPE_SHOLAT_SHUBUH){
                splitData = waktuShubuh.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
            if(type == TYPE_SHOLAT_SYURUQ){
                splitData = waktuSyuruk.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
            if(type == TYPE_SHOLAT_DHUHA){
                splitData = waktuDhuha.split(":")
                hour = splitData[0].toInt()
                minute = splitData[1].toInt()
            }
    
            calendar.set(Calendar.HOUR_OF_DAY,hour)
            calendar.set(Calendar.MINUTE,minute)
            calendar.set(Calendar.SECOND, 0)
    
            if(calendar.before(Calendar.getInstance())){
                calendar.add(Calendar.DATE, 1)
            }
            Log.d("time", calendar.time.toString())
            return calendar
        }
    
        private fun getNotificationIntent(type: String, context: Context?): Intent {
            val intent = Intent(context, NotificationReceiver::class.java)
            intent.putExtra(NOTIFICATION_TYPE, type)
            Log.d("intent nya", type)
            return intent
        }
    
        fun setNotificationWaktuSholat(context: Context) {
            val pendingIntentDzuhur = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_DZUHUR, getNotificationIntent(
                    TYPE_SHOLAT_DZUHUR, context
                ), 0
            )
            val pendingIntentAshar = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_ASHAR, getNotificationIntent(
                    TYPE_SHOLAT_ASHAR, context
                ), 0
            )
            val pendingIntentMaghrib = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_MAGHRIB, getNotificationIntent(
                    TYPE_SHOLAT_MAGHRIB, context
                ), 0
            )
            val pendingIntentIsya = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_ISYA, getNotificationIntent(
                    TYPE_SHOLAT_ISYA, context
                ), 0
            )
            val pendingIntentNisfuLail = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_NISFLU_LAIL, getNotificationIntent(
                    TYPE_SHOLAT_NISFU_LAIL, context
                ), 0
            )
            val pendingIntentShubuh = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_SHUBUH, getNotificationIntent(
                    TYPE_SHOLAT_SHUBUH, context
                ), 0
            )
            val pendingIntentSyuruq = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_SYURUQ, getNotificationIntent(
                    TYPE_SHOLAT_SYURUQ, context
                ), 0
            )
            val pendingIntentDhuha = PendingIntent.getBroadcast(
                context,
                ID_NOTIFICATION_SHOLAT_DHUHA, getNotificationIntent(
                    TYPE_SHOLAT_DHUHA, context
                ), 0
            )
    
            val alarmManager =
                context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_DZUHUR, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentDzuhur
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_ASHAR, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentAshar
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_MAGHRIB, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentMaghrib
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_ISYA, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentIsya
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_NISFU_LAIL, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentNisfuLail
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_SHUBUH, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentShubuh
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_SYURUQ, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentSyuruq
            )
            alarmManager.setInexactRepeating(
                AlarmManager.RTC_WAKEUP,
                getReminderTime(TYPE_SHOLAT_DHUHA, context).timeInMillis,
                AlarmManager.INTERVAL_DAY,
                pendingIntentDhuha
            )
        }
    
        private fun showNotificationWaktuSholat(context: Context?, title: String) {
            val sharedPreferencesSetting = PreferenceManager.getDefaultSharedPreferences(context)
            val modePemberitahuan = sharedPreferencesSetting.getString("mode_pemberitahuan", "mode_getar")
    
            val NOTIFICATION_ID = 1
            val CHANNEL_ID = "channel_waktu_sholat"
            val CHANNEL_NAME = "Waktu Sholat"
    
            val intent = Intent(context, MainActivity::class.java)
            val pendingIntent = PendingIntent.getActivity(
                context,
                NOTIFICATION_ID,
                intent,
                PendingIntent.FLAG_UPDATE_CURRENT
            )
    
            var uriRingtone: Uri? = null
            when (modePemberitahuan) {
                "mode_getar" -> {
                    uriRingtone =
                    RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
                    Log.d("mode", "getar")
                }
                "mode_suara" -> {
                    uriRingtone =
                        Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context!!.packageName + "/" + R.raw.adzan)
                    Log.d("mode", "suara")
                }
                "mode_diam" -> {
                    uriRingtone = null
                    Log.d("mode", "diam")
                }
            }
    
            val notificationManager=
                context!!.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
            val noficationBuilder = NotificationCompat.Builder(context, CHANNEL_ID)
                .setSmallIcon(R.drawable.ic_logo_notif)
                .setLargeIcon(
                    (ResourcesCompat.getDrawable(
                        context.resources,
                        R.drawable.ic_logo_islamic_times,
                        null
                    ))!!.toBitmap()
                )
                .setContentTitle(title)
                .setContentText("Yuk mari kita sholat :)")
                .setContentIntent(pendingIntent)
                .setAutoCancel(true)
                .setSound(uriRingtone)
                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                val attributes = AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_NOTIFICATION)
                    .build()
    
                val channel = NotificationChannel(
                    CHANNEL_ID,
                    CHANNEL_NAME,
                    NotificationManager.IMPORTANCE_DEFAULT
                )
                channel.description = CHANNEL_NAME
                channel.setSound(uriRingtone, attributes)
                Log.d("RINGTONE ", uriRingtone.toString())
                noficationBuilder.setChannelId(CHANNEL_ID)
                notificationManager.createNotificationChannel(channel)
            }
            val notification: Notification = noficationBuilder.build()
            notificationManager.notify(NOTIFICATION_ID, notification)
        }
    
        private fun cancelNotification(context: Context?, type: String) {
            val alarmManager: AlarmManager =
                context!!.getSystemService(Context.ALARM_SERVICE) as AlarmManager
            val intent = Intent(context, NotificationReceiver::class.java)
            var requestCode = 0
            if (type.equals(TYPE_SHOLAT_DZUHUR, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_DZUHUR
            }
            if (type.equals(TYPE_SHOLAT_ASHAR, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_ASHAR
            }
            if (type.equals(TYPE_SHOLAT_MAGHRIB, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_MAGHRIB
            }
            if (type.equals(TYPE_SHOLAT_ISYA, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_ISYA
            }
            if (type.equals(TYPE_SHOLAT_NISFU_LAIL, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_NISFLU_LAIL
            }
            if (type.equals(TYPE_SHOLAT_SHUBUH, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_SHUBUH
            }
            if (type.equals(TYPE_SHOLAT_SYURUQ, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_SYURUQ
            }
            if (type.equals(TYPE_SHOLAT_DHUHA, false)) {
                requestCode =
                    ID_NOTIFICATION_SHOLAT_DHUHA
            }
            val pendingIntent = PendingIntent.getBroadcast(context, requestCode, intent, 0)
            pendingIntent.cancel()
            alarmManager.cancel(pendingIntent)
        }
    
        fun cancelNotificationWaktuSholat(context: Context?) {
            cancelNotification(context,
                TYPE_SHOLAT_DZUHUR
            )
            cancelNotification(context,
                TYPE_SHOLAT_ASHAR
            )
            cancelNotification(context,
                TYPE_SHOLAT_MAGHRIB
            )
            cancelNotification(context,
                TYPE_SHOLAT_ISYA
            )
            cancelNotification(context,
                TYPE_SHOLAT_NISFU_LAIL
            )
            cancelNotification(context,
                TYPE_SHOLAT_SHUBUH
            )
            cancelNotification(context,
                TYPE_SHOLAT_SYURUQ
            )
            cancelNotification(context,
                TYPE_SHOLAT_DHUHA
            )
        }
    }

我就这样在MainActivity的onCreate中设置了通知

MainActivity.kt

class MainActivity : AppCompatActivity() {
     private val notification = NotificationReceiver()
     override fun onCreate(savedInstanceState: Bundle?) {
         notification.setNotificationWaktuSholat(this)
     }
}

我做错了什么

0 个答案:

没有答案
相关问题