I have a notification and when I tap it I want to launch application if it is still not running, but if application already running, I do not want to relaunch it.
So, I am using PendingIntent.FLAG_UPDATE_CURRENT flag when creating PendingIntent.
My code:
private val notificationManager by lazy { NotificationManagerCompat.from(this) }
fun testPush() {
val notificationBuilder = NotificationCompat.Builder(this, BuildConfig.APPLICATION_ID)
.setSmallIcon(R.drawable.ill_launcher)
notificationBuilder
.setContentTitle("Title")
.setContentText("Test text")
.setContentIntent(buildPendingIntent())
notificationBuilder
.setAutoCancel(true)
.priority = NotificationCompat.PRIORITY_DEFAULT
notificationManager.notify(1, notificationBuilder.build())
}
private fun buildPendingIntent(): PendingIntent {
val intent = Intent(this, RootActivity::class.java)
intent.flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
intent.putExtra("action", RootActivity.DEFAULT_INTENT)
return PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
}
But when I launch the application and click on the notification, the activity is recreates.
Instead of building the Intent for RootActivity like you are doing, you need to create a "launch Intent" for your application. The easiest way to do this is to call PackageManager.getLaunchIntentForPackage() and pass your own package name. Use the returned Intent in the call to PendingIntent.getActivity().
This will launch your app if it isn't running, otherwise, if it is already running, it will just bring the existing task containing your app to the foreground.
Related
I have an Activity, which has a fragment. In that fragment, I launch a service witch I need to do some stuff in the background. When some condition come to true in the service, I create a push notification, where i specify to reopen the activity (and load the fragment) when the notification is clicked.
The problem is that when i click the notification, the activity is destroyed and recreated again, and on the onDestroy method of the activity, I shut down the service (i want to kill it when the user close the app), so the service is no more running anymore.
How can i prevent the activity to be destroyed and recreated but simply resumed (like moving my self through the multitasking)?
How i create the notification:
val intent = Intent(context, SplashScreenActivity::class.java)
val pendingIntent = PendingIntent.getActivity(context, 0, intent, FLAG_ACTIVITY_SINGLE_TOP)
val builder = NotificationCompat.Builder(
ApplicationServices.instance.applicationContext,
channelId
)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(title)
.setContentText(message)
.setStyle(NotificationCompat.BigTextStyle().bigText(message))
.setDefaults(NotificationCompat.DEFAULT_ALL)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setContentIntent(pendingIntent)
.setAutoCancel(true)
``
Try this:
// Activity Intent
val intent = Intent(context, SplashScreenActivity::class.java).apply {
// Note: Add flag(s) for Activity here
flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
}
// Pending Intent
val pendingIntent = PendingIntent.getActivity(
context,
// Note: Use a non-zero positive Integer here, it's good practice ;-)
System.currentTimeMillis().toInt(),
intent,
// Note: Add flag(s) for Pending Intent here
PendingIntent.FLAG_UPDATE_CURRENT
)
// Notification Builder
val builder = NotificationCompat.Builder(
ApplicationServices.instance.applicationContext,
channelId
)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(title)
.setContentText(message)
.setStyle(NotificationCompat.BigTextStyle().bigText(message))
.setDefaults(NotificationCompat.DEFAULT_ALL)
.setPriority(NotificationCompat.PRIORITY_HIGH)
// Using Pending Intent
.setContentIntent(pendingIntent)
.setAutoCancel(true)
I have a problem about activity created twice.
When the notification appears, the activity will appear because of the fullscreen intent. At this time, I press the home button and click the notification, and the activity is actually created again.
I tried to use singletop and it didn't work.
Log shows the same task, but the hash is different.
Log.e("Task", "task id: $taskId, hash: ${hashCode()}")
val pendingIntent = PendingIntent.getActivity(context, 0, Intent(context, MainActivity::class.java).apply {
addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)
}, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
val builder = NotificationCompat.Builder(context, "Alarm")
.setSmallIcon(R.drawable.ic_launcher_background)
.setContentTitle("Title")
.setContentText("Content")
.setContentIntent(pendingIntent)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setFullScreenIntent(pendingIntent, true)
UPDATE!!!
I solved this problem. The problem was with remoteMessage.notification.let {
which is triggered only when app is in foreground state, thus I removed this part and it worked like a charm)
When I send push notification and when app is in background state notification is coming but whem I click it is not doing anything. But when app is in foreground, the click is taking to an app again.
Here is some code from FirebaseMessagingService
remoteMessage.notification.let {
val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
val intent = Intent(this, MainActivity::class.java)
.putExtra(CLICK_ACTION, mapData.get("click_action"))
.putExtra(PAGE_TO_GO, mapData.get("pagetogo"))
.putExtra(NOTIFIATION_TITLE, mapData.get("title"))
.putExtra(NOTIFICATION_BODY, mapData.get("body"))
.putExtra(COMPANY_ID, mapData.get("company_id"))
.putExtra(DOCUMENT_ID, mapData.get("document_id"))
.putExtra(ORDER_ID, mapData.get("order_id"))
.putExtra(FROM_DATE_EXTRA, mapData.get("from_date"))
.putExtra(TO_DATE_EXTRA, mapData.get("to_date"))
.putExtra(LEDGER_VIEW_ID_EXTRA, mapData.get("id_for_ledge_view"))
.putExtra(IS_CREDIT_EXTRA, mapData.get("is_credit"))
intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
val pendingIntent = PendingIntent.getActivity(this, REQUEST_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT)
val notification = NotificationCompat.Builder(this, getString(R.string.channel_id))
.setSmallIcon(R.drawable.ic_baseline_notifications_24)
.setContentTitle(it?.title)
.setContentText(it?.body)
.setContentIntent(pendingIntent)
.setStyle(
NotificationCompat.BigTextStyle()
.bigText(it?.body)
)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setAutoCancel(true)
with(notificationManager) {
notify(NOTIFICATION_ID, notification.build())
}
I solved this problem. The problem was with remoteMessage.notification.let { which is triggered only when app is in foreground state, thus I removed this part and it worked like a charm)
My app has one activity and one service. The service starts a foreground notification that has an action button that in some situations needs to tell the activity to do something besides just coming back to the front. It uses the Extras to indicate this something.
My issues are that I can't find any documentation on how to receive explicit intents other than through the "bundle" passed to onCreate() which isn't usually called because the activity could already be created.
How do you receive an intent after onCreate()?
Notification code snippet:
val actionIntent = Intent(this, MainActivity::class.java)
actionIntent.action = actionText
actionIntent.flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP
val pendingActionIntent: PendingIntent = PendingIntent.getActivity(this, 0, actionIntent, 0)
val actionCancel: NotificationCompat.Action = NotificationCompat.Action.Builder(R.drawable.ic_cancel_black_24dp,
actionText,
pendingActionIntent).build()
val notificationBuilder: NotificationCompat.Builder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
.setContentTitle(getText(R.string.notification_title))
.setSmallIcon(R.drawable.ic_logo_24dp)
.setContentIntent(pendingIntent)
.setOnlyAlertOnce(true)
.addAction(actionCancel)
.setContentText(text)
startForeground(ONGOING_NOTIFICATION_ID, notificationBuilder.build())
Override onNewIntent(). If the activity already exists, and an Intent is bringing it back to the foreground, that Intent is delivered to onNewIntent().
I am using an external library in our project. That library showing notification. On tapping that notification starts activity in the library.
I want to detect that activity launch from push notification to track some analytics data.
Is there any way to detect those notification taps or activity launch?
As far as I understand you activity is already launched on notification tap. For detecting activity launch you can use ActivityLifecycleCallbacks. In such case you will need to override onActivityCreated/onActivityStarted which includes created/started activity as argument. You can inject analytics component inside and send events about launched activities.
class AppLifecycleCallbacks : ActivityLifecycleCallbacks {
override fun onActivityStarted(activity: Activity) {
if (activity is MyActivity) {
//...
}
}
//...
}
Pass some extra meta data along with your pending intent generated for showing notification. And parse same in your destination activity.
Intent destination = new Intent(context, HomeActivity.class);
destination.putExtra("SOURCE","NOTIFICATION");
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, destination, PendingIntent.FLAG_CANCEL_CURRENT);
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(context)
.setContentTitle("Notification Title")
.setAutoCancel(true)
.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
.setContentIntent(pendingIntent)
.setContentInfo("App")
.setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.mipmap.ic_launcher))
.setColor(context.getColor(R.color.colorAccent))
.setLights(Color.RED, 1000, 300)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setSmallIcon(R.drawable.ic_like);
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
And in activity level :
if(getIntent().getStringExtra("SOURCE").equals("NOTIFICATION")){
// launched from notification
}
If your activity is already running your intent might get delivered to :
#Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
}
Of course, yes. When you create Intent for launching your target activity you can pass arguments to the intent and when Activity starts just obtain outer arguments from intent and if these arguments came from Notification do your actions need.