Develop Reference

Why does my alarm not cancel after setting it with thesame request code

I set my alarm this way:
val broadcastReceiverIntent = Intent(context, AlarmReceiver::class.java)
broadcastReceiverIntent.putExtra(Constants.ALARM_INTENT_TIME, alarm.time)
broadcastReceiverIntent.putExtra(Constants.ALARM_INTENT_ID, alarm.id)
broadcastReceiverIntent.action = System.currentTimeMillis().toString()
val newPendingIntent = PendingIntent.getBroadcast(
context,
alarm.id?:0,
broadcastReceiverIntent,
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
)
//schedule alarm
val alarmClockInfo = AlarmManager.AlarmClockInfo(calendar.timeInMillis, null)
alarmManager.setAlarmClock(alarmClockInfo, newPendingIntent)
Then I cancel this way:
val broadcastReceiverIntent = Intent(context, AlarmReceiver::class.java)
val newPendingIntent = PendingIntent.getBroadcast(
context,
alarm.id?:0,
broadcastReceiverIntent,
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
)
alarmManager.cancel(newPendingIntent)
The alarm still fires off, even when I cancel it.
The request code I used to set the alarm is thesame as the one I am using to cancel it.
What could be the cause?

The problem was from:
broadcastReceiverIntent.action = System.currentTimeMillis().toString()
when setting that alarm.
It appears that that same action is required to cancel the alarm.
Removing that line solved the problem.

Alarm Pending intent returns null when app started again after killing from background

I am trying to check if a repeating alarm already exist. I am testing in MIUI 11 (OS v8.1) device, where i have set an alarm then removed the application from background. If i again opens the app a new alarm is created again
Here is my code to set a repeating alarm
private fun startAlarm() {
val CUSTOM_INTENT = "com.test.intent.action.ALARM"
val intent = Intent(this, AlarmHelper::class.java)
intent.action = CUSTOM_INTENT
val pendingIntent: PendingIntent =
getBroadcast(this, 101, intent, PendingIntent.FLAG_UPDATE_CURRENT)
val alarmManager = getSystemService(ALARM_SERVICE) as AlarmManager
alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(),
System.currentTimeMillis()+60*60*1000, pendingIntent)
}
This checks if an alarm already exist then i will not create a new one.
private fun isAlarmExist() :Boolean =
PendingIntent.getBroadcast(this, 101,
Intent(this, AlarmHelper::class.java),
PendingIntent.FLAG_NO_CREATE) != null
Already tried this
private fun isAlarmExist() :Boolean =
PendingIntent.getBroadcast(this, 101,
Intent("com.example.dozemodepoc.MY_UNIQUE_ACTION"),
PendingIntent.FLAG_NO_CREATE) != null
// this didnot work either
Already gone through
How to check if AlarmManager already has an alarm set?
When force stopped the application and started the app again, new instance is again created. Any kind of help will be highly appreciated!!.

I did a silly mistake in my isAlarmExist()
private fun isAlarmExist() :Boolean {
val CUSTOM_INTENT = "com.test.intent.action.ALARM"
val intent = Intent(this#MainActivity, AlarmHelper::class.java)
intent.action = CUSTOM_INTENT
return getBroadcast(this#MainActivity, 101, intent, PendingIntent.FLAG_NO_CREATE)!=null
}
This pending intent should be exact of the pending intent which was created when alarm was set up.

Schedule Android function when App is closed at specific time

I want to create an App that throws a notification everyday at 20pm. For that I need to time a function that gets executed every day at 20pm. Whats the best way to solve this? What should I use?
This is the function I want to execute:
private fun throwNotification() {
notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
val intent = Intent(applicationContext, MainActivity::class.java)
val pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
notificationChannel = NotificationChannel(channelId, description, NotificationManager.IMPORTANCE_HIGH)
notificationChannel.enableLights(true)
notificationChannel.lightColor = Color.RED
notificationChannel.enableVibration(true)
notificationManager.createNotificationChannel(notificationChannel)
builder = Notification.Builder(this, channelId)
.setContentTitle("Test")
.setContentText("This is a test notification")
.setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(pendingIntent)
.setAutoCancel(true)
.setChannelId(channelId)
notificationManager.notify(0, builder.build())
}

You should be concerned following tasks.
The function should be executed at exactly 20pm.
#1 should be repeated everyday.
The notification should be pushed even if the app is closed.
Above issues should not matter whether the device restarts.
The solution I found is following and that requires the app should be launched at least once.
#1~3 can be implemented by AlarmManager.
At app's first launch, call following code that registers alarmIntent.
private var alarmMgr: AlarmManager? = null
private lateinit var alarmIntent: PendingIntent
alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmIntent = Intent(context, YourAlarmReceiver::class.java).let { intent ->
PendingIntent.getBroadcast(context, 0, intent, 0)
}
// Set the alarm to start at 20:00.
val calendar: Calendar = Calendar.getInstance().apply {
timeInMillis = System.currentTimeMillis()
set(Calendar.HOUR_OF_DAY, 20)
set(Calendar.MINUTE, 0)
set(Calendar.SECOND, 0)
}
// setRepeating() lets you specify a precise custom interval--in this case,
// 1 day.
alarmMgr?.setRepeating(
AlarmManager.RTC_WAKEUP,
calendar.timeInMillis,
1000 * 60 * 60 * 24,
alarmIntent
)
Here, YourAlarmReceiver's onReceive() will be called at every 20pm by alarmIntent.
So what you have to do is only calling throwNotification() inside this onReceive().
#4 is also easy, that being said, it can be implemented by listening to BOOT_COMPLETED event.

Open activity after click in notification in alarmmanager and broadcast Kotlin

I set on my application the notification every 7 hours in this way:
alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
val intent = Intent(this, AlarmBroadcastReceiver::class.java)
pendingIntent = PendingIntent.getBroadcast(this, REQUEST_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT)
// Setting the specific time for the alarm manager to trigger the intent, in this example, the alarm is set to go off at 23:30, update the time according to your need
val calendar = Calendar.getInstance()
val next= calendar.get(Calendar.HOUR_OF_DAY) + 7
calendar.timeInMillis = System.currentTimeMillis()
calendar.set(Calendar.HOUR_OF_DAY, next)
calendar.set(Calendar.MINUTE, 0)
calendar.set(Calendar.SECOND, 0)
// Starts the alarm manager
alarmManager.setRepeating(
AlarmManager.RTC_WAKEUP,
calendar.timeInMillis,
AlarmManager.INTERVAL_DAY,
pendingIntent
)
with this class AlarmBroadcastReceiver :
class AlarmBroadcastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// Create the NotificationChannel
val name = "Alarme"
val descriptionText = "Detalhes do Alarme"
val importance = NotificationManager.IMPORTANCE_DEFAULT
val mChannel = NotificationChannel("AlarmId", name, importance)
mChannel.description = descriptionText
val notificationManager = context?.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(mChannel)
}
// Create the notification to be shown
val mBuilder = NotificationCompat.Builder(context!!, "AlarmId")
.setSmallIcon(R.mipmap.ic_food)
.setContentTitle("Synchronize Fitbit")
.setContentText("Synchronize Fitbit data and log-in SugarFree for don't lose daily data")
.setAutoCancel(true)
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
// Get the Notification manager service
val am = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
// Generate an Id for each notification
val id = System.currentTimeMillis() / 1000
// Show a notification
am.notify(id.toInt(), mBuilder.build())
The notifications working well, I enter in the application, set the alarm and after 7 hours arrive the notification and so on. I wish that when arrive the notification i can click on it and open the app (maybe in my current home activity) so this alarm wish set automatically after 7 hours.
I saw that I must modify the pendingIntent with my home intent... but I have a
val intent = Intent(this, AlarmBroadcastReceiver::class.java)
that need to call the Alarm Receiver class.
Can anyone help me out?

All you need is to add .setContentIntent in your notification builder.
// Create the notification to be shown
val mBuilder = NotificationCompat.Builder(context!!, "AlarmId")
.setSmallIcon(R.mipmap.ic_food)
.setContentTitle("Synchronize Fitbit")
.setContentText("Synchronize Fitbit data and log-in SugarFree for don't lose daily data")
.setAutoCancel(true)
.setContentIntent(PendingIntent.getActivity(
context, // Context from onReceive method.
0,
Intent(context, HomeActivity::class.java), // Activity you want to launch onClick.
0
)
)
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.build()
You can find out more here the docs have more information about how to handle tasks such as only single Activity opens at a time.

You need create and set pending intent -
// Create an Intent for the activity you want to start
val resultIntent = Intent(this, YourMainActivity::class.java)
// Create the TaskStackBuilder
val resultPendingIntent: PendingIntent? = TaskStackBuilder.create(this).run {
// Add the intent, which inflates the back stack
addNextIntentWithParentStack(resultIntent)
// Get the PendingIntent containing the entire back stack
getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT)
}
and then set it -
val builder = NotificationCompat.Builder(this, CHANNEL_ID).apply {
setContentIntent(resultPendingIntent)
...
}
with(NotificationManagerCompat.from(this)) {
notify(NOTIFICATION_ID, builder.build())
}
Hope this will work for you.

How to remove the notification after the particular time in android?

I am creating an simple android application in that created a notification.
Now i want to remove the notification if the user doesn't response after the particular time
That means i want remove the notification after five mins

The current correct solution may be to use:
NotificationCompat.Builder#setTimeoutAfter(long)

What you need is a combination of Alarmmanager and notificationmanger.
Register the alarm manager that will call a service in 5 minutes and use NotificationManager.cancel in the service implementation.
Alarm Service Sample is here. I suppose you know to use Notification Manager.

AlarmManager is more often used for complicated Services that have to run in the Background when the Application is closed.
You could also use a classic Java Runnable in a Handler for a simple small Thread.
Handler h = new Handler();
long delayInMilliseconds = 5000;
h.postDelayed(new Runnable() {
public void run() {
mNotificationManager.cancel(id);
}
}, delayInMilliseconds);
Also look here:
Clearing notification after a few seconds
You could also use the TimerTask-Class.

For Android >= 8.0 (Oreo) we can use this,
NotificationCompat.Builder#setTimeoutAfter(long)
For Android < 8.0 we can use AlarmManager
Add this to AndroidManifest.xml :
<receiver
android:name=".AutoDismissNotification"/>
Create AutoDismissNotification.kt and add this code :
class AutoDismissNotification : BroadcastReceiver() {
companion object {
private const val KEY_EXTRA_NOTIFICATION_ID = "notification_id"
}
override fun onReceive(context: Context, intent: Intent) {
val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.cancel(intent.getIntExtra(KEY_EXTRA_NOTIFICATION_ID, 0))
}
fun setAlarm(context: Context, notificationId: Int, time: Long) {
val alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
val alarmIntent = Intent(context, AutoDismissNotification::class.java)
alarmIntent.putExtra(KEY_EXTRA_NOTIFICATION_ID, notificationId)
val alarmPendingIntent = PendingIntent.getBroadcast(context, notificationId, alarmIntent, PendingIntent.FLAG_ONE_SHOT)
alarmMgr.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + time, alarmPendingIntent)
}
fun cancelAlarm(context: Context, notificationId: Int) {
val alarmIntent = Intent(context, AutoDismissNotification::class.java)
alarmIntent.putExtra(KEY_EXTRA_NOTIFICATION_ID, notificationId)
val alarmPendingIntent = PendingIntent.getBroadcast(context, notificationId, alarmIntent, PendingIntent.FLAG_ONE_SHOT)
val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmManager.cancel(alarmPendingIntent)
}
}
When you build the notification, add this :
long timeOut = 5 * 1000L; // Five seconds
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
builder.setTimeoutAfter(timeOut);
}
else {
AutoDismissNotification().setAlarm(this, notificationId, timeOut);
}

You can create your notification like this.
NotificationCompat.Builder notification = new NotificationCompat.Builder(context)
.setSmallIcon(Util.getNotificationIcon(context))
.setContentTitle(new SessionManager().getDomainPreference(context))
.setAutoCancel(true)
.setOngoing(false)
.setPriority(NotificationCompat.PRIORITY_MAX)
.setShowWhen(false)
.setContentText(summaryText)
.setTimeoutAfter(3000) // add time in milliseconds
.setChannelId(CHANNEL_ID);