intent = new Intent(context, NotificationBroadcastReceiver.class);
intent.setAction(REPLY_ACTION);
intent.putExtra(KEY_NOTIFICATION_ID, notificationId);
intent.putExtra(KEY_MESSAGE_ID, messageId);
PendingIntent replyPendingIntent = PendingIntent.getBroadcast(
        getApplicationContext(), 100, intent,
        PendingIntent.FLAG_UPDATE_CURRENT);

// Key for the string that's delivered in the action's intent.
private static final String KEY_TEXT_REPLY = "key_text_reply";
String replyLabel = getResources().getString(R.string.reply_label);
RemoteInput remoteInput = new RemoteInput.Builder(KEY_TEXT_REPLY)
        .setLabel(replyLabel)
        .build();

// Create the reply action and add the remote input.
Notification.Action action =
        new Notification.Action.Builder(R.drawable.ic_reply_icon,
                getString(R.string.label), replyPendingIntent)
                .addRemoteInput(remoteInput)
                .build();

// Build the notification and add the action.
Notification newMessageNotification =
        new Notification.Builder(mContext)
                .setSmallIcon(R.drawable.ic_message)
                .setContentTitle(getString(R.string.title))
                .setContentText(getString(R.string.content))
                .addAction(action)
                .build();

// Issue the notification.
NotificationManager notificationManager =
        (NotificationManager) this.getSystemService(NOTIFICATION_SERVICE);
notificationManager.notify(notificationId, newMessageNotification);

private CharSequence getReplyMessage(Intent intent) {
    Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
    if (remoteInput != null) {
        return remoteInput.getCharSequence(KEY_REPLY);
    }
    return null;
}

public void onReceive(Context context, Intent intent) {
    if (REPLY_ACTION.equals(intent.getAction())) {
        CharSequence message = getReplyMessage(intent);
        int messageId = intent.getIntExtra(KEY_MESSAGE_ID, 0);

        Toast.makeText(context, "Message ID: " + messageId + "\nMessage: " + message,
                Toast.LENGTH_SHORT).show();
    }
}

Notification notification = new Notification.Builder()
             .setSmallIcon(R.drawable.ic_menu_camera)
             .setStyle(new Notification.MessagingStyle("Me")
                 .setConversationTitle("Team lunch")
                 .addMessage("Hi", timestamp1, null) // Pass in null for user.
                 .addMessage("What's up?", timestamp2, "Coworker")
                 .addMessage("Not much", timestamp3, null)
                 .addMessage("How about lunch?", timestamp4, "Coworker"))
             .build();

public Builder setShowWhen(boolean show) {
  mN.extras.putBoolean(EXTRA_SHOW_WHEN, show);
  return this;
}

public Builder setSmallIcon(Icon icon) {
  mN.setSmallIcon(icon);
  if (icon != null && icon.getType() == Icon.TYPE_RESOURCE) {
      mN.icon = icon.getResId();
  }
  return this;
}


public Builder setContentTitle(CharSequence title) {
  mN.extras.putCharSequence(EXTRA_TITLE, safeCharSequence(title));
  return this;
}

public Builder setContentText(CharSequence text) {
  mN.extras.putCharSequence(EXTRA_TEXT, safeCharSequence(text));
  return this;
}

public Builder setContentInfo(CharSequence info) {
  mN.extras.putCharSequence(EXTRA_INFO_TEXT, safeCharSequence(info));
  return this;
}

public Builder setProgress(int max, int progress, boolean indeterminate) {
  mN.extras.putInt(EXTRA_PROGRESS, progress);
  mN.extras.putInt(EXTRA_PROGRESS_MAX, max);
  mN.extras.putBoolean(EXTRA_PROGRESS_INDETERMINATE, indeterminate);
  return this;
}

public Builder setStyle(Style style) {
  if (mStyle != style) {
      mStyle = style;
      if (mStyle != null) {
          mStyle.setBuilder(this);
          mN.extras.putString(EXTRA_TEMPLATE, style.getClass().getName());
      }  else {
          mN.extras.remove(EXTRA_TEMPLATE);
      }
  }
  return this;
}

public void notifyAsUser(String tag, int id, Notification notification, UserHandle user)
{
   int[] idOut = new int[1];
   INotificationManager service = getService(); ①
   String pkg = mContext.getPackageName();
   // Fix the notification as best we can.
   Notification.addFieldsFromContext(mContext, notification); ②
   if (notification.sound != null) {
       notification.sound = notification.sound.getCanonicalUri();
       if (StrictMode.vmFileUriExposureEnabled()) {
           notification.sound.checkFileUriExposed("Notification.sound");
       }
   }
   fixLegacySmallIcon(notification, pkg);
   if (mContext.getApplicationInfo().targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
       if (notification.getSmallIcon() == null) {
           throw new IllegalArgumentException("Invalid notification (no valid small icon): "
                   + notification); ③
       }
   }
   if (localLOGV) Log.v(TAG, pkg + ": notify(" + id + ", " + notification + ")");
   final Notification copy = Builder.maybeCloneStrippedForDelivery(notification);
   try {
       service.enqueueNotificationWithTag(pkg, mContext.getOpPackageName(), tag, id,
               copy, idOut, user.getIdentifier()); ④
       if (localLOGV && id != idOut[0]) {
           Log.v(TAG, "notify: id corrupted: sent " + id + ", got back " + idOut[0]);
       }
   } catch (RemoteException e) {
       throw e.rethrowFromSystemServer();
   }
}

final StatusBarNotification n = new StatusBarNotification(
      pkg, opPkg, id, tag, callingUid, callingPid, 0, notification,
      user);

final NotificationRecord r = new NotificationRecord(getContext(), n);

final NotificationRecord r = new NotificationRecord(getContext(), n);
mHandler.post(new EnqueueNotificationRunnable(userId, r));

public void onNotificationPosted(final StatusBarNotification sbn,
      final RankingMap rankingMap) {
  if (DEBUG) Log.d(TAG, "onNotificationPosted: " + sbn);
  if (sbn != null) {
      mHandler.post(new Runnable() {
          @Override
          public void run() {
              processForRemoteInput(sbn.getNotification());
              String key = sbn.getKey(); ①
              mKeysKeptForRemoteInput.remove(key);
              boolean isUpdate = mNotificationData.get(key) != null; ②
              if (!ENABLE_CHILD_NOTIFICATIONS
                  && mGroupManager.isChildInGroupWithSummary(sbn)) {
                  if (DEBUG) {
                      Log.d(TAG, "Ignoring group child due to existing summary: " + sbn);
                  }

                  // Remove existing notification to avoid stale data.
                  if (isUpdate) {
                      removeNotification(key, rankingMap); ③
                  } else {
                      mNotificationData.updateRanking(rankingMap);
                  }
                  return;
              }
              if (isUpdate) {
                  updateNotification(sbn, rankingMap);
              } else {
                  addNotification(sbn, rankingMap, null /* oldEntry */); ④
              }
          }
      });
  }
}

protected void updateNotifications() {
   mNotificationData.filterAndSort();

   updateNotificationShade();
   mIconController.updateNotificationIcons(mNotificationData);
}

private void updateNotificationShade() {
   if (mStackScroller == null) return;

   // Do not modify the notifications during collapse.
   if (isCollapsing()) {
       addPostCollapseAction(new Runnable() {
           @Override
           public void run() {
               updateNotificationShade();
           }
       });
       return;
   }

   ArrayList<Entry> activeNotifications = mNotificationData.getActiveNotifications();
   ArrayList<ExpandableNotificationRow> toShow = new ArrayList<>(activeNotifications.size());
   final int N = activeNotifications.size();
   for (int i=0; i<N; i++) {
       Entry ent = activeNotifications.get(i);
       int vis = ent.notification.getNotification().visibility;

       // Display public version of the notification if we need to redact.
       final boolean hideSensitive =
               !userAllowsPrivateNotificationsInPublic(ent.notification.getUserId());
       boolean sensitiveNote = vis == Notification.VISIBILITY_PRIVATE;
       boolean sensitivePackage = packageHasVisibilityOverride(ent.notification.getKey());
       boolean sensitive = (sensitiveNote && hideSensitive) || sensitivePackage;
       boolean showingPublic = sensitive && isLockscreenPublicMode();
       if (showingPublic) {
           updatePublicContentView(ent, ent.notification);
       }
       ent.row.setSensitive(sensitive, hideSensitive);
       if (ent.autoRedacted && ent.legacy) {
           // TODO: Also fade this? Or, maybe easier (and better), provide a dark redacted form
           // for legacy auto redacted notifications.
           if (showingPublic) {
               ent.row.setShowingLegacyBackground(false);
           } else {
               ent.row.setShowingLegacyBackground(true);
           }
       }
       if (mGroupManager.isChildInGroupWithSummary(ent.row.getStatusBarNotification())) {
           ExpandableNotificationRow summary = mGroupManager.getGroupSummary(
                   ent.row.getStatusBarNotification());
           List<ExpandableNotificationRow> orderedChildren =
                   mTmpChildOrderMap.get(summary);
           if (orderedChildren == null) {
               orderedChildren = new ArrayList<>();
               mTmpChildOrderMap.put(summary, orderedChildren);
           }
           orderedChildren.add(ent.row);
       } else {
           toShow.add(ent.row);
       }

   }

   ArrayList<ExpandableNotificationRow> toRemove = new ArrayList<>();
   for (int i=0; i< mStackScroller.getChildCount(); i++) {
       View child = mStackScroller.getChildAt(i);
       if (!toShow.contains(child) && child instanceof ExpandableNotificationRow) {
           toRemove.add((ExpandableNotificationRow) child);
       }
   }

   for (ExpandableNotificationRow remove : toRemove) {
       if (mGroupManager.isChildInGroupWithSummary(remove.getStatusBarNotification())) {
           // we are only transfering this notification to its parent, don't generate an animation
           mStackScroller.setChildTransferInProgress(true);
       }
       if (remove.isSummaryWithChildren()) {
           remove.removeAllChildren();
       }
       mStackScroller.removeView(remove);
       mStackScroller.setChildTransferInProgress(false);
   }

   removeNotificationChildren();

   for (int i=0; i<toShow.size(); i++) {
       View v = toShow.get(i);
       if (v.getParent() == null) {
           mStackScroller.addView(v);
       }
   }

   addNotificationChildrenAndSort();

   // So after all this work notifications still aren't sorted correctly.
   // Let's do that now by advancing through toShow and mStackScroller in
   // lock-step, making sure mStackScroller matches what we see in toShow.
   int j = 0;
   for (int i = 0; i < mStackScroller.getChildCount(); i++) {
       View child = mStackScroller.getChildAt(i);
       if (!(child instanceof ExpandableNotificationRow)) {
           // We don't care about non-notification views.
           continue;
       }

       ExpandableNotificationRow targetChild = toShow.get(j);
       if (child != targetChild) {
           // Oops, wrong notification at this position. Put the right one
           // here and advance both lists.
           mStackScroller.changeViewPosition(targetChild, i);
       }
       j++;

   }

   // clear the map again for the next usage
   mTmpChildOrderMap.clear();

   updateRowStates();
   updateSpeedbump();
   updateClearAll();
   updateEmptyShadeView();

   updateQsExpansionEnabled();
   mShadeUpdates.check();
}