I want to display notification message in notification area on android. Now this display only application Title.
I am looking in logcat but I dont see no System.out ouput from line System.out.println(newMessage);
I have this class:
/**
* Author : Taufan E.
* App Name : The Restaurant App
* Release Date : October 2012
*/
package com.the.restaurant;
public class Home extends Activity {
String gcm_regId="";
static DBHelper dbhelper;
MainMenuAdapter mma;
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.home);
//GCMRegistrar.unregister(this);
// Make sure the device has the proper dependencies.
GCMRegistrar.checkDevice(this);
// Make sure the manifest was properly set - comment out this line
// while developing the app, then uncomment it when it's ready.
//GCMRegistrar.checkManifest(this);
gcm_regId = GCMRegistrar.getRegistrationId(this);
if(gcm_regId.equals("")){
GCMRegistrar.register(this, Utils.SENDER_ID);
}
System.out.println(gcm_regId);
registerReceiver(mHandleMessageReceiver, new IntentFilter("com.the.restaurant.DISPLAY_MESSAGE"));
if (!Utils.isNetworkAvailable(Home.this)) {
Toast.makeText(Home.this, getString(R.string.no_internet), Toast.LENGTH_SHORT).show();
}
mma = new MainMenuAdapter(this);
dbhelper = new DBHelper(this);
listMainMenu.setAdapter(mma);
}
#Override
protected void onPause(){
super.onPause();
unregisterReceiver(mHandleMessageReceiver);
}
#Override
protected void onResume(){
super.onResume();
registerReceiver(mHandleMessageReceiver, new IntentFilter("com.the.restaurant.DISPLAY_MESSAGE"));
}
private void displayNotification(final Context theContext,String message){
long when = System.currentTimeMillis();
int icon = R.drawable.cover_image;
NotificationManager notificationManager = (NotificationManager)
theContext.getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification = new Notification(icon, message, when);
String title = theContext.getString(R.string.app_name);
Intent notificationIntent = new Intent();
// set intent so it does not start a new activity
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent intent = PendingIntent.getActivity(theContext, 0, notificationIntent, 0);
notification.setLatestEventInfo(theContext, title, message, intent);
notification.flags |= Notification.FLAG_AUTO_CANCEL;
// Play default notification sound
notification.defaults |= Notification.DEFAULT_SOUND;
// Vibrate if vibrate is enabled
notification.defaults |= Notification.DEFAULT_VIBRATE;
notificationManager.notify(0, notification);
}
private final BroadcastReceiver mHandleMessageReceiver = new BroadcastReceiver() {
#Override
public void onReceive(Context context, Intent intent) {
String newMessage = intent.getExtras().getString("rezervare");
// Waking up mobile if it is sleeping
WakeLocker.acquire(getApplicationContext());
/**
* Take appropriate action on this message
* depending upon your app requirement
* For now i am just displaying it on the screen
* */
// Showing received message
//lblMessage.append(newMessage + "\n");
System.out.println(newMessage);
Toast.makeText(getApplicationContext(), "New Message: " + newMessage, Toast.LENGTH_LONG).show();
displayNotification(context,newMessage);
//sendnotification("The Restaurant App","Mesaj");
//GCMRegistrar.unregister(Reservation.class);
// Releasing wake lock
WakeLocker.release();
}
};
}
You'll need to build the notification first:
// Pop up Notification
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle("New Notification Title")
.setContentText("This is notification content.");
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, ClassToLaunch.class);
// The stack builder object will contain an artificial back stack for the
// started Activity.
// This ensures that navigating backward from the Activity leads out of
// your application to the Home screen.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent (but not the Intent itself)
stackBuilder.addParentStack(ClassToLaunch.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT
);
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify("tag", mBuilder.build());
As per your question you can't see output from following line:
System.out.println(newMessage);
And also you want to display the notification which I can see will be displayed after the following method is executed:
displayNotification(context,newMessage);
Answer:
The code that you are expecting to be executed is under the onReceive method of a BroadcastReceiver which means this method onReceive will be called when a special intent is generated which it is registered to in your onCreate method on the line:
registerReceiver(mHandleMessageReceiver, new IntentFilter("com.the.restaurant.DISPLAY_MESSAGE"));
You can broadcast Intent in the following manner:
Intent intent = new Intent();
intent.setAction("com.the.restaurant.DISPLAY_MESSAGE");
sendBroadcast(intent); ///sendBroadcast is a Context (Activity) method
Related
I have try all the methods but it doesn't work for me. i want to open or resume app with whatever screen open while click on notification.
I used following method:
NotificationCompat.BigTextStyle notiStyle = new NotificationCompat.BigTextStyle();
notiStyle.setBigContentTitle(team);
notiStyle.bigText(message);
Intent resultIntent = new Intent(this, MainDrawerActivity.class);
resultIntent.putExtra("fromNotification", "notification");
resultIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_SINGLE_TOP);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
PendingIntent.FLAG_UPDATE_CURRENT);
int icon = R.mipmap.ic_launcher;
return new NotificationCompat.Builder(this).setSmallIcon(icon)
.setAutoCancel(true)
.setContentIntent(resultPendingIntent).setContentTitle(team)
.setContentText(message).setStyle(notiStyle).build();
To raise your application to the foreground without starting any new activity, fire its launcher intent.
This method is from an old project of mine.
/**
* Creates a new launcher intent, equivalent to the intent generated by
* clicking the icon on the home screen.
*
* #return the launcher intent
*/
public static Intent newLauncherIntent(final Context context) {
final Intent intent = new Intent(context, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setAction(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
return intent;
}
The intent created by this method does not start a new task if the app is running, even though it has that flag.
This is another way to obtain a launcher intent. However, I found that this intent would always start a new task, which is not what you want if the app is running.
final Intent intent = context.getPackageManager()
.getLaunchIntentForPackage(BuildConfig.APPLICATION_ID);
This is working fine for following three conditions:
1.if app already open and click on notification, notification should remove from status bar.
2.if app is open and in background then app should resume with whatever screen open already previously.
3.if app is close and click on notification in status bar then app should open.
private final static int NORMAL = 0x00;
private final static int BIG_TEXT_STYLE = 0x01;
private static NotificationManager mNotificationManager;
in onMessage call
mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
new CreateNotification(BIG_TEXT_STYLE, team, message).execute();
then declare following class in GCMIntentService.
public class CreateNotification extends AsyncTask {
int style = NORMAL;
String team, message;
public CreateNotification(int style, String team, String message) {
this.style = style;
this.team = team;
this.message = message;
}
#Override
protected Void doInBackground(Void... params) {
Notification noti = new Notification();
switch (style) {
case BIG_TEXT_STYLE:
noti = setBigTextStyleNotification(team, message);
break;
}
noti.sound = (null);
noti.defaults = 0;
noti.sound = Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.beep);
noti.flags |= Notification.FLAG_AUTO_CANCEL;
mNotificationManager.notify(0, noti);
return null;
}
}
and finally
private Notification setBigTextStyleNotification(String team, String message) {
// Create the style object with BigTextStyle subclass.
NotificationCompat.BigTextStyle notiStyle = new NotificationCompat.BigTextStyle();
notiStyle.setBigContentTitle(team);
notiStyle.bigText(message);
Intent resultIntent = getPackageManager()
.getLaunchIntentForPackage(getPackageName());
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the Intent that starts the Activity to the top of the stack.
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
PendingIntent.FLAG_UPDATE_CURRENT);
int icon = R.mipmap.ic_launcher;
return new NotificationCompat.Builder(this).setSmallIcon(icon)
.setAutoCancel(true)
.setContentIntent(resultPendingIntent).setContentTitle(team)
.setContentText(message).setStyle(notiStyle).build();
}
You should have something like this in Application class to store the current activity.
private BaseActivity mCurrentActivity = null;
public BaseActivity getCurrentActivity() {
return mCurrentActivity;
}
public void setCurrentActivity(BaseActivity currentActivity) {
this.mCurrentActivity = currentActivity;
}
Then, inside your handle notification Service class.
#Override
public void onMessageReceived(RemoteMessage remoteMessage) {
super.onMessageReceived(remoteMessage);
BaseActivity currentActivity = ((App) this.getApplicationContext())
.getCurrentActivity();
Intent intent;
if (currentActivity instanceof ActivityA) {
intent = new Intent(this, ActivityA.class);
} else if (currentActivity instanceof ActivityB) {
intent = new Intent(this, ActivityB.class);
} else {
intent = new Intent(this, MainActivity.class);
}
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
// your code...
}
If your app is killed, default activity will be called, such as MainActivity.
Else, when you receive & click push notification message when app is on foreground or background. Current activity will stay there as default activity, such as ActivityA & ActivityB. Then you can navigate to wherever another activities or fragments.
My suggestion, better we should use Fragment, it's easier in navigate to specially screen from push notification.
//I am using write now this can possible
NotificationManager notificationManager = (NotificationManager) context
.getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification = new Notification(icon, message, when);
Intent notificationIntent = new Intent(context, HomeActivity.class);
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent intent = PendingIntent.getActivity(context, 0,
notificationIntent, 0);
notification.setLatestEventInfo(context, title, message, intent);
notification.flags |= Notification.FLAG_AUTO_CANCEL;
notificationManager.notify(0, notification);
If you want to just resume the app state then instead of multiple activity I will suggest you just keep single activity and use Fragments for different screen.
On Notification click you need to define entry point of app in notification payload and the entry point decide what will be the next navigation.
If you are having only single activity then you can define that activity as a entry point and on the activity you can decide do you have to push new fragment or not.
Or second option if you are using firebase then push all notification as background notification and onMessageReceive method you can get top activity from activity stack and set that activity as entry point for the notification. But there is still problem as user may be click on notification after navigate from set entry point activity which again problem. So I prefer to go with first one approach.
make new activity
public class FinishImmediateActivity extends AppCompatActivity {
#Override protected void onCreate(#Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
finish();
}
}
add to manifest.xml
<activity android:name=".FinishImmediateActivity"/>
check app is running
public static boolean isMainActivityRunning() {
ActivityManager activityManager = (ActivityManager) MyApp.getContext().getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> tasksInfo = activityManager.getRunningTasks(Integer.MAX_VALUE);
for (int i = 0; i < tasksInfo.size(); i++) {
if (tasksInfo.get(i).baseActivity.getPackageName().equals(MyApp.getContext().getPackageName())) {
return true;
}
}
return false;
}
then call that activity in notification intent.
Intent resultIntent = new Intent(this, isMainActivityRunning() ? FinishImmediateActivity.class : HomeActivity.class);
By this way also we can achieve the above result:
try {
int icon;
icon = R.mipmap.ic_launcher;
int mNotificationId = 001;
Intent intent = new Intent(this, MainDrawerActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
//FLAG_UPDATE_CURRENT is important
PendingIntent pendingIntent = PendingIntent.getActivity(this,
(int)System.currentTimeMillis(), intent,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder mBuilder = new
NotificationCompat.Builder(
this);
Notification notification =
mBuilder.setSmallIcon(icon).setTicker(json.getString("team")).setWhen(0)
.setAutoCancel(true)
.setContentTitle(json.getString("team"))
.setStyle(new
NotificationCompat.BigTextStyle().bigText(json.getString("message")))
.setContentIntent(pendingIntent)
.setSound(Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.beep))
NotificationManager notificationManager = (NotificationManager)
this.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(mNotificationId, notification);
} catch (Exception e) {
e.printStackTrace();
}
I am using Google Cloud Messaging to send push notifications in android application.I have an activity page in which i maintained the tab bar layouts.For example,If I received five notifications means and from the five, i have clicked the fourth one, it will go to the first received notification page instead of fourth received notification page.It will redirect to the same page for all notifications.
public class MainActivity extends Activity {
private NotificationManager myNotificationManager;
private int notificationIdOne = 111;
private int notificationIdTwo = 112;
private int numMessagesOne = 0;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button notOneBtn = (Button) findViewById(R.id.notificationOne);
notOneBtn.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
displayNotificationOne();
displayNotificationTwo();
}
});
}
protected void displayNotificationOne() {
// Invoking the default notification service
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this);
mBuilder.setContentTitle("New Message with explicit intent");
mBuilder.setContentText("New message from javacodegeeks received");
mBuilder.setTicker("Explicit: New Message Received!");
mBuilder.setSmallIcon(R.drawable.ic_launcher);
mBuilder.setAutoCancel(true);
// Increase notification number every time a new notification arrives
mBuilder.setNumber(++numMessagesOne);
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, NotificationOne.class);
resultIntent.putExtra("notificationId", notificationIdOne);
resultIntent.putExtra("notificationtext", "One");
//This ensures that navigating backward from the Activity leads out of the app to Home page
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent
stackBuilder.addParentStack(NotificationOne.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT //can only be used once
);
// start the activity when the user clicks the notification text
mBuilder.setContentIntent(resultPendingIntent);
myNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// pass the Notification object to the system
myNotificationManager.notify(notificationIdOne, mBuilder.build());
}
protected void displayNotificationTwo() {
// Invoking the default notification service
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this);
mBuilder.setContentTitle("New Message with 222");
mBuilder.setContentText("Message from 222");
mBuilder.setTicker("2222 New Message Received!");
mBuilder.setSmallIcon(R.drawable.ic_launcher);
mBuilder.setAutoCancel(true);
// Increase notification number every time a new notification arrives
mBuilder.setNumber(++numMessagesOne);
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, NotificationOne.class);
resultIntent.putExtra("notificationId", notificationIdTwo);
resultIntent.putExtra("notificationtext", "two");
//This ensures that navigating backward from the Activity leads out of the app to Home page
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent
stackBuilder.addParentStack(NotificationOne.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT //can only be used once
);
// start the activity when the user clicks the notification text
mBuilder.setContentIntent(resultPendingIntent);
myNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// pass the Notification object to the system
myNotificationManager.notify(notificationIdTwo, mBuilder.build());
}
}
Hello I am working on android app where I am using GCM concept. Once app receive notification then on click I am starting MainActivity.
If MainActivity is already running and app receive notification then already running MainActivity should finish and restart, and if it not running then simply start it.
There should be flag to do this same. can anyone help me what is that flag ?
GcmIntentService.java.
public class GcmIntentService extends IntentService {
public GcmIntentService() {
super("GcmIntentService");
}
public static final String TAG = "GcmIntentService";
#Override
protected void onHandleIntent(Intent intent) {
Bundle extras = intent.getExtras();
GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
String messageType = gcm.getMessageType(intent);
String message = extras.getString("message").toString();
String notificationTitle = extras.getString("title");
if (!extras.isEmpty()) {
if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
sendNotification(message, notificationTitle);
}
}
// Release the wake lock provided by the WakefulBroadcastReceiver.
GcmBroadcastReceiver.completeWakefulIntent(intent);
}
// Put the message into a notification and post it.
// This is just one simple example of what you might choose to do with
// a GCM message.
private void sendNotification(String msg, String notificationTitle) {
NotificationManager mNotificationManager = (NotificationManager)
this.getSystemService(Context.NOTIFICATION_SERVICE);
Intent notificationIntent = new Intent(this, ActivityMain.class);
notificationIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
notificationIntent.putExtra("notification_message", msg);
notificationIntent.putExtra("notification", true);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
NotificationCompat.Builder mBuilder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.app_icon)
.setContentTitle(notificationTitle)
.setStyle(new NotificationCompat.BigTextStyle()
.bigText(msg))
.setContentText(msg);
mBuilder.setDefaults(-1);
mBuilder.setAutoCancel(true);
mBuilder.setContentIntent(contentIntent);
mNotificationManager.notify((int)System.currentTimeMillis(), mBuilder.build());
}
If your MainActivity is not running, it will be opened/started (no problem here). In case it is already running then the onNewIntent() method (in your MainActivity) will be called. So you can override it as following:
#Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
init(); //this method will reload the data, or whatever you want to do
}
Try This:
NotificationCompat.Builder mBuilder =new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle(sender)
.setContentText(message);
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(context, MainActivity.class);
// The stack builder object will contain an artificial back stack for the
// started Activity.
// This ensures that navigating backward from the Activity leads out of
// your application to the Home screen.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
// Adds the back stack for the Intent (but not the Intent itself)
stackBuilder.addParentStack(LoginScreen.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification=mBuilder.build();
notification.flags |= Notification.FLAG_AUTO_CANCEL;
// Play default notification sound
notification.defaults |= Notification.DEFAULT_SOUND;
// Vibrate if vibrate is enabled
notification.defaults |= Notification.DEFAULT_VIBRATE;
// mId allows you to update the notification later on.
mNotificationManager.notify(msg_ID,notification);
You first need to call finish() and then restart MainActivity
finish(); //Close current activity
startActivity(getIntent()); //Restart it
Do this in your main activity to start Activity:
Intent notificationIntent = new Intent(this, MainActivity.class);
startActivity(notificationIntent);
finish();
In your Notification activity intent reopen the Main Activity :
Intent mainIntent = new Intent(this, MainActivity.class);
startActivity(mainIntent);
finish();
I have been searching a lot of questions and answers in stackoverflow. I am still not able to solve my problem.
I set broadcast for a particular time.
I receive the broadcast perfectly in another class 'AlarmReceiver.java' which creates notification on receiving broadcast.
But I pass a string through an intent that calls a class 'AlarmResponder.java' on pressing the notification.
The class is getting called.
I receive the String data i passed through the intent only for the first time.
Next time I dont get anything. getextras() gives me null .
If i change the ID of the notification in NotificationManager.notify(1, mBuilder.build()); as
NotificationManager.notify(2, mBuilder.build()); it works .
But always it works only once
Please help me
public class AlarmReceiver extends BroadcastReceiver{
#Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
CharSequence reminderText = intent.getCharSequenceExtra("reminderText");
if (reminderText != null && reminderText != "") {
Uri notification = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
Ringtone r = RingtoneManager.getRingtone(context, notification);
r.play();
//Toast.makeText(context, intent.getCharSequenceExtra("reminderText"), Toast.LENGTH_LONG).show();
NotificationCompat.Builder mBuilder =
new NotificationCompat.Builder(context)
.setSmallIcon(R.drawable.ic_launcher)
.setContentTitle(reminderText)
.setContentText("its time buddy");
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(context, AlarmResponder.class);
resultIntent.putExtra("reminderText", reminderText);
resultIntent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
// The stack builder object will contain an artificial back stack for the
// started Activity.
// This ensures that navigating backward from the Activity leads out of
// your application to the Home screen.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
// Adds the back stack for the Intent (but not the Intent itself)
stackBuilder.addParentStack(AlarmResponder.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT
);
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =
(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
// mId allows you to update the notification later on.
mNotificationManager.notify(1, mBuilder.build());
}
}
}
and the AlarmResponder class is
public class AlarmResponder extends Activity{
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
onNewIntent(getIntent());
}
#Override
public void onNewIntent(Intent intent){
Bundle extras = intent.getExtras();
if(extras != null){
if(extras.containsKey("reminderText"))
{
setContentView(R.layout.alarm_responder);
TextView reminderText = (TextView) findViewById(R.id.reminderText);
// extract the extra-data in the Notification
String msg = extras.getString("reminderText");
reminderText.setText(msg);
}
}
}
}
Right now I am creating a notification intent as per the following:
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
Intent notificationIntent = new Intent(context, MyActivity.class);
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
notificationIntent.setAction(Long.toString(System.currentTimeMillis()));
notificationIntent.putExtra("key", value);
PendingIntent contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, 0);
Notification updateComplete = new NotificationCompat.Builder(context)
.setContentTitle(title)
.setContentText(msg)
.setTicker(title)
.setWhen(System.currentTimeMillis())
.setContentIntent(contentIntent)
.setDefaults(Notification.DEFAULT_SOUND)
.setAutoCancel(true)
.setSmallIcon(R.drawable.icon_notifications)
.build();
notificationManager.notify(100, updateComplete);
When the app is already in the background, everything works. The function onNewIntent is called and I get the value from the notificationIntent extras. However, if the app is NOT in the background, it goes to the root activity (login screen) which forwards the user to MyActivity. But the root activity doesn't get the call to onNewIntent, and by the time the user gets to MyActivity, the extras are lost.
Is there anyway around this?
I have been trying to store values elsewhere to no avail... This includes shared preferences.
#Override
protected void onMessage(final Context ctx, Intent intent) {
if (CommonMethod.isAppicationRunning(ctx)) {
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(ctx, ViewMessageDialog.class);
resultIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
resultIntent.putExtra("gcmmessage", message);
ctx.startActivity(resultIntent);
} else {
try {
sendNotification(message);
} catch (JSONException e) {
e.printStackTrace();
}
}
}
////////////////////////////////////////////////////////////////////////////
public static boolean isAppicationRunning(Context activity) {
ActivityManager am = (ActivityManager) activity
.getSystemService(EGLifeStyleApplication.mContext.ACTIVITY_SERVICE);
// get the info from the currently running task
List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1);
ComponentName componentInfo = taskInfo.get(0).topActivity;
Log.i("current activity", "activity"
+ activity.getClass().getSimpleName());
if (componentInfo.getPackageName().equals(
EGLifeStyleApplication.mContext.getPackageName())) {
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////////
private void sendNotification(String message) throws JSONException {
// this
String ns = Context.NOTIFICATION_SERVICE;
NotificationManager mNotificationManager = (NotificationManager) getSystemService(ns);
int icon = R.drawable.app_icon;
CharSequence tickerText = message; // ticker-text
long when = System.currentTimeMillis();
Context context = getApplicationContext();
context.getClass().getSimpleName();
Log.i("context.getClass().getSimpleName()",
"context.getClass().getSimpleName()="
+ context.getClass().getSimpleName());
CharSequence contentTitle = "Product Received.";
CharSequence contentText = message;
Intent notificationIntent = null;
int notificationID = CommonVariable.notificationID;
notificationIntent = new Intent(this, ViewHomeScreen.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
notificationIntent, 0);
Notification notification = new Notification(icon, tickerText, when);
// Play default notification sound
notification.defaults |= Notification.DEFAULT_ALL;
notification.setLatestEventInfo(context, contentTitle, contentText,
contentIntent);
mNotificationManager.notify(notificationID, notification);
}
check app running or not?if app is running in forgroung then please call only intent to pass that specific activity.and if app is running in backgroung then call sendnotification() to send notification on notification bar.
//this code is put in your gcmservice
Intent intent2 = new Intent();
intent2.setAction("RECEIVE_MESSAGE_ACTION_NEW");
intent2.putExtra("senderNum", senderNum);
intent2.putExtra("verificationCode",
ReturnValidationcode(message));
context.sendBroadcast(intent2);
Check this out. I don't know why your activity should run to get the upadate. If you follow that tutorial, then the mobile will automatically get push notification, if there are any. No need to run activity on background.
I found out how to do this.
Basically, if the activity you are launching with notificationIntent is already open (if it's the current activity the user is on), it will call onNewIntent(Intent intent). If it is not currently the active activity or if the application is not running, it will launch the activity and go to onCreate().
You have to get the intent from onCreate() by calling getIntent() and checking to see it's not null. Case closed.