title: Android Firebase push notification not showing
body: <p>Hey I am trying to send a push notification to my app using Firebase and I am learning from this tutorial <a href="http://www.androidhive.info/2012/10/android-push-notifications-using-google-cloud-messaging-gcm-php-and-mysql/" rel="nofollow noreferrer">http://www.androidhive.info/2012/10/android-push-notifications-using-google-cloud-messaging-gcm-php-and-mysql/</a></p>
  
  <p>when I go in to the firebase notification and send notification it tells me that the state is complete but doesn't send any notifications to my app and I can't figure out why.. I followed this tutorial exactly</p>
  
  <p>here is the code I took from the tutorial:</p>
  
  <p>Config class</p>
  
  <pre><code>public class Config {
  
          public static final String TOPIC_GLOBAL = "global";
  
          public static final String REGISTRATION_COMPLETE = "registrationComplete";
  public static final String PUSH_NOTIFICATION = "pushNotification";
  
          public static final int NOTIFICATION_ID = 100;
  public static final int NOTIFICATION_ID_BIG_IMAGE = 101;
  
          public static final String SHARED_PREF = "ah_firebase";
  </code></pre>
  
  <p>}</p>
  
  <p>MyFirebaseInstanceIDService class</p>
  
  <pre><code>public class MyFirebaseInstanceIDService extends FirebaseInstanceIdService {
  
  private static final String TAG = MyFirebaseInstanceIDService.class.getSimpleName();
  
  @Override
  public void onTokenRefresh() {
      super.onTokenRefresh();
      String refreshedToken = FirebaseInstanceId.getInstance().getToken();
  
      // Saving reg id to shared preferences
      storeRegIdInPref(refreshedToken);
  
      // sending reg id to your server
      sendRegistrationToServer(refreshedToken);
  
      // Notify UI that registration has completed, so the progress indicator can be hidden.
      Intent registrationComplete = new Intent(Config.REGISTRATION_COMPLETE);
      registrationComplete.putExtra("token", refreshedToken);
      LocalBroadcastManager.getInstance(this).sendBroadcast(registrationComplete);
  }
  
  private void sendRegistrationToServer(final String token) {
      // sending gcm token to server
      Log.e(TAG, "sendRegistrationToServer: " + token);
  }
  
  private void storeRegIdInPref(String token) {
      SharedPreferences pref = getApplicationContext().getSharedPreferences(Config.SHARED_PREF, 0);
      SharedPreferences.Editor editor = pref.edit();
      editor.putString("regId", token);
      editor.commit();
  }
  </code></pre>
  
  <p>}</p>
  
  <p>MyFirebaseMessagingService class</p>
  
  <pre><code>public class MyFirebaseMessagingService extends FirebaseMessagingService {
  
  private static final String TAG = MyFirebaseMessagingService.class.getSimpleName();
  
  private NotificationUtils notificationUtils;
  
  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
      Log.e(TAG, "From: " + remoteMessage.getFrom());
  
      if (remoteMessage == null)
          return;
  
      // Check if message contains a notification payload.
      if (remoteMessage.getNotification() != null) {
          Log.e(TAG, "Notification Body: " + remoteMessage.getNotification().getBody());
          handleNotification(remoteMessage.getNotification().getBody());
      }
  
      // Check if message contains a data payload.
      if (remoteMessage.getData().size() &gt; 0) {
          Log.e(TAG, "Data Payload: " + remoteMessage.getData().toString());
  
          try {
              JSONObject json = new JSONObject(remoteMessage.getData().toString());
              handleDataMessage(json);
          } catch (Exception e) {
              Log.e(TAG, "Exception: " + e.getMessage());
          }
      }
  }
  
  private void handleNotification(String message) {
      if (!NotificationUtils.isAppIsInBackground(getApplicationContext())) {
          // app is in foreground, broadcast the push message
          Intent pushNotification = new Intent(Config.PUSH_NOTIFICATION);
          pushNotification.putExtra("message", message);
          LocalBroadcastManager.getInstance(this).sendBroadcast(pushNotification);
  
          // play notification sound
          NotificationUtils notificationUtils = new NotificationUtils(getApplicationContext());
          notificationUtils.playNotificationSound();
      }else{
          // If the app is in background, firebase itself handles the notification
      }
  }
  
  private void handleDataMessage(JSONObject json) {
      Log.e(TAG, "push json: " + json.toString());
  
      try {
          JSONObject data = json.getJSONObject("data");
  
          String title = data.getString("title");
          String message = data.getString("message");
          boolean isBackground = data.getBoolean("is_background");
          String imageUrl = data.getString("image");
          String timestamp = data.getString("timestamp");
          JSONObject payload = data.getJSONObject("payload");
  
          Log.e(TAG, "title: " + title);
          Log.e(TAG, "message: " + message);
          Log.e(TAG, "isBackground: " + isBackground);
          Log.e(TAG, "payload: " + payload.toString());
          Log.e(TAG, "imageUrl: " + imageUrl);
          Log.e(TAG, "timestamp: " + timestamp);
  
  
          if (!NotificationUtils.isAppIsInBackground(getApplicationContext())) {
              // app is in foreground, broadcast the push message
              Intent pushNotification = new Intent(Config.PUSH_NOTIFICATION);
              pushNotification.putExtra("message", message);
              LocalBroadcastManager.getInstance(this).sendBroadcast(pushNotification);
  
              // play notification sound
              NotificationUtils notificationUtils = new NotificationUtils(getApplicationContext());
              notificationUtils.playNotificationSound();
          } else {
              // app is in background, show the notification in notification tray
              Intent resultIntent = new Intent(getApplicationContext(), MainActivity.class);
              resultIntent.putExtra("message", message);
  
              // check for image attachment
              if (TextUtils.isEmpty(imageUrl)) {
                  showNotificationMessage(getApplicationContext(), title, message, timestamp, resultIntent);
              } else {
                  // image is present, show notification with image
                  showNotificationMessageWithBigImage(getApplicationContext(), title, message, timestamp, resultIntent, imageUrl);
              }
          }
      } catch (JSONException e) {
          Log.e(TAG, "Json Exception: " + e.getMessage());
      } catch (Exception e) {
          Log.e(TAG, "Exception: " + e.getMessage());
      }
  }
  
  /**
   * Showing notification with text only
   */
  private void showNotificationMessage(Context context, String title, String message, String timeStamp, Intent intent) {
      notificationUtils = new NotificationUtils(context);
      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
      notificationUtils.showNotificationMessage(title, message, timeStamp, intent);
  }
  
  /**
   * Showing notification with text and image
   */
  private void showNotificationMessageWithBigImage(Context context, String title, String message, String timeStamp, Intent intent, String imageUrl) {
      notificationUtils = new NotificationUtils(context);
      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
      notificationUtils.showNotificationMessage(title, message, timeStamp, intent, imageUrl);
  }
  </code></pre>
  
  <p>}</p>
  
  <p>NotificationUtil class</p>
  
  <pre><code>public class NotificationUtils {
  
  private static String TAG = NotificationUtils.class.getSimpleName();
  
          private Context mContext;
  
          public NotificationUtils(Context mContext) {
      this.mContext = mContext;
      }
  
  public void showNotificationMessage(String title, String message, String timeStamp, Intent intent) {
      showNotificationMessage(title, message, timeStamp, intent, null);
      }
  
          public void showNotificationMessage(final String title, final String message, final String timeStamp, Intent intent, String imageUrl) {
      if (TextUtils.isEmpty(message))
      return;
  
      final int icon = R.mipmap.ic_launcher;
  
      intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
      final PendingIntent resultPendingIntent =
      PendingIntent.getActivity(
              mContext,
              0,
              intent,
              PendingIntent.FLAG_CANCEL_CURRENT
              );
  
      final NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(
              mContext);
  
      final Uri alarmSound = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
              + "://" + mContext.getPackageName() + "/raw/notification");
  
      if (!TextUtils.isEmpty(imageUrl)) {
  
          if (imageUrl != null &amp;&amp; imageUrl.length() &gt; 4 &amp;&amp; Patterns.WEB_URL.matcher(imageUrl).matches()) {
  
              Bitmap bitmap = getBitmapFromURL(imageUrl);
  
              if (bitmap != null) {
                  showBigNotification(bitmap, mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
              } else {
                  showSmallNotification(mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
              }
          }
          } else {
          showSmallNotification(mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
          playNotificationSound();
          }
      }
  
  
          private void showSmallNotification(NotificationCompat.Builder mBuilder, int icon, String title, String message, String timeStamp, PendingIntent resultPendingIntent, Uri alarmSound) {
  
      NotificationCompat.InboxStyle inboxStyle = new NotificationCompat.InboxStyle();
  
      inboxStyle.addLine(message);
  
      Notification notification;
      notification = mBuilder.setSmallIcon(icon).setTicker(title).setWhen(0)
      .setAutoCancel(true)
      .setContentTitle(title)
      .setContentIntent(resultPendingIntent)
      .setSound(alarmSound)
      .setStyle(inboxStyle)
      .setWhen(getTimeMilliSec(timeStamp))
      .setSmallIcon(R.mipmap.ic_launcher)
      .setLargeIcon(BitmapFactory.decodeResource(mContext.getResources(), icon))
              .setContentText(message)
      .build();
  
      NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
      notificationManager.notify(Config.NOTIFICATION_ID, notification);
      }
  
  private void showBigNotification(Bitmap bitmap, NotificationCompat.Builder mBuilder, int icon, String title, String message, String timeStamp, PendingIntent resultPendingIntent, Uri alarmSound) {
      NotificationCompat.BigPictureStyle bigPictureStyle = new NotificationCompat.BigPictureStyle();
      bigPictureStyle.setBigContentTitle(title);
      bigPictureStyle.setSummaryText(Html.fromHtml(message).toString());
      bigPictureStyle.bigPicture(bitmap);
      Notification notification;
      notification = mBuilder.setSmallIcon(icon).setTicker(title).setWhen(0)
     .setAutoCancel(true)
     .setContentTitle(title)
     .setContentIntent(resultPendingIntent)
     .setSound(alarmSound)
              .setStyle(bigPictureStyle)
      .setWhen(getTimeMilliSec(timeStamp))
      .setSmallIcon(R.mipmap.ic_launcher)
      .setLargeIcon(BitmapFactory.decodeResource(mContext.getResources(), icon))
      .setContentText(message)
      .build();
  
      NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
      notificationManager.notify(Config.NOTIFICATION_ID_BIG_IMAGE, notification);
      }
  
         public Bitmap getBitmapFromURL(String strURL) {
          try {
         URL url = new URL(strURL);
          HttpURLConnection connection = (HttpURLConnection) url.openConnection();
          connection.setDoInput(true);
          connection.connect();
          InputStream input = connection.getInputStream();
          Bitmap myBitmap = BitmapFactory.decodeStream(input);
          return myBitmap;
          } catch (IOException e) {
          e.printStackTrace();
          return null;
          }
      }
  
          // Playing notification sound
          public void playNotificationSound() {
      /*try {
          Uri alarmSound = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
                  + "://" + mContext.getPackageName() + "/raw/notification");
          Ringtone r = RingtoneManager.getRingtone(mContext, alarmSound);
          r.play();
          } catch (Exception e) {
          e.printStackTrace();
          }*/
      }
  
  public static boolean isAppIsInBackground(Context context) {
      boolean isInBackground = true;
      ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
      if (Build.VERSION.SDK_INT &gt; Build.VERSION_CODES.KITKAT_WATCH) {
          List&lt;ActivityManager.RunningAppProcessInfo&gt; runningProcesses = am.getRunningAppProcesses();
          for (ActivityManager.RunningAppProcessInfo processInfo : runningProcesses) {
              if (processInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                  for (String activeProcess : processInfo.pkgList) {
                      if (activeProcess.equals(context.getPackageName())) {
                          isInBackground = false;
                          }
                      }
                  }
              }
          } else {
          List&lt;ActivityManager.RunningTaskInfo&gt; taskInfo = am.getRunningTasks(1);
        ComponentName componentInfo = taskInfo.get(0).topActivity;
          if (componentInfo.getPackageName().equals(context.getPackageName())) {
              isInBackground = false;
              }
          }
  
      return isInBackground;
      }
  
  public static void clearNotifications(Context context) {
      NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
      notificationManager.cancelAll();
      }
  
  public static long getTimeMilliSec(String timeStamp) {
      SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      try {
          Date date = format.parse(timeStamp);
          return date.getTime();
          } catch (ParseException e) {
          e.printStackTrace();
          }
      return 0;
      }
  </code></pre>
  
  <p>}</p>
  
  <p>MainActivity</p>
  
  <pre><code>    txtRegId = (TextView)findViewById(R.id.txt_reg_id);
      txtMessage = (TextView)findViewById(R.id.txt_push_message);
  
      mRegistrationBroadcastReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
  
              if (intent.getAction().equals(Config.REGISTRATION_COMPLETE)) {
                  FirebaseMessaging.getInstance().subscribeToTopic(Config.TOPIC_GLOBAL);
  
                  displayFirebaseRegId();
  
                  } else if (intent.getAction().equals(Config.PUSH_NOTIFICATION)) {
  
                  String message = intent.getStringExtra("message");
  
                  Toast.makeText(getApplicationContext(), "Push notification: " + message, Toast.LENGTH_LONG).show();
  
                  txtMessage.setText(message);
                  }
              }
          };
  
      displayFirebaseRegId();
  
  
  }
  
  private void displayFirebaseRegId() {
      SharedPreferences pref = getApplicationContext().getSharedPreferences(Config.SHARED_PREF, 0);
      String regId = pref.getString("regId", null);
  
      Log.e(TAG, "Firebase reg id: " + regId);
  
      if (!TextUtils.isEmpty(regId))
      txtRegId.setText("Firebase Reg Id: " + regId);
      else
      txtRegId.setText("Firebase Reg Id is not received yet!");
      }
  
  @Override
  protected void onResume() {
      super.onResume();
  
      LocalBroadcastManager.getInstance(this).registerReceiver(mRegistrationBroadcastReceiver,
              new IntentFilter(Config.REGISTRATION_COMPLETE));
  
  
      LocalBroadcastManager.getInstance(this).registerReceiver(mRegistrationBroadcastReceiver,
              new IntentFilter(Config.PUSH_NOTIFICATION));
      NotificationUtils.clearNotifications(getApplicationContext());
  }
  
  @Override
  protected void onPause() {
      LocalBroadcastManager.getInstance(this).unregisterReceiver(mRegistrationBroadcastReceiver);
      super.onPause();
  }
  </code></pre>