Android中的Notification机制深入理解

notificationcompat.builder mbuilder =
  new notificationcompat.builder(this)
  .setsmallicon(r.drawable.notification_icon)
  .setwhen(system.currenttimemillis())
  .setcontenttitle("test notification title")
  .setcontenttext("test notification content!");
intent resultintent = new intent(this, resultactivity.class);

pendingintent contentintent =
  pendingintent.getactivity(
   this, 
   0, 
   resultintent, 
   pendingintent.flag_update_current
  );
mbuilder.setcontentintent(resultpendingintent);
notificationmanager mnotificationmanager =
 (notificationmanager) getsystemservice(context.notification_service);
// mid allows you to update the notification later on.
mnotificationmanager.notify(mid, mbuilder.build());

public void notify(int id, notification notification)
{
 notify(null, id, notification);
}

// 省略部分注释
public void notify(string tag, int id, notification notification)
{
 notifyasuser(tag, id, notification, new userhandle(userhandle.myuserid()));
}

/**
 * @hide
 */
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();
 }
}

@override
public void enqueuenotificationwithtag(string pkg, string oppkg, string tag, int id,
   notification notification, int[] idout, int userid) throws remoteexception {
 enqueuenotificationinternal(pkg, oppkg, binder.getcallinguid(),
   binder.getcallingpid(), tag, id, notification, idout, userid);
}

void enqueuenotificationinternal(final string pkg, final string oppkg, final int callinguid,
  final int callingpid, final string tag, final int id, final notification notification,
  int[] idout, int incominguserid) {
 if (dbg) {
  slog.v(tag, "enqueuenotificationinternal: pkg=" + pkg + " id=" + id
    + " notification=" + notification);
 }
 checkcallerissystemorsameapp(pkg);
 final boolean issystemnotification = isuidsystem(callinguid) || ("android".equals(pkg));
 final boolean isnotificationfromlistener = mlisteners.islistenerpackage(pkg);

 final int userid = activitymanager.handleincominguser(callingpid,
   callinguid, incominguserid, true, false, "enqueuenotification", pkg);
 final userhandle user = new userhandle(userid);

 // fix the notification as best we can.
 try {
  final applicationinfo ai = getcontext().getpackagemanager().getapplicationinfoasuser(
    pkg, packagemanager.match_debug_triaged_missing,
    (userid == userhandle.user_all) ? userhandle.user_system : userid);
  notification.addfieldsfromcontext(ai, userid, notification);
 } catch (namenotfoundexception e) {
  slog.e(tag, "cannot create a context for sending app", e);
  return;
 }

 musagestats.registerenqueuedbyapp(pkg);

 if (pkg == null || notification == null) {
  throw new illegalargumentexception("null not allowed: pkg=" + pkg
    + " id=" + id + " notification=" + notification);
 }
 final statusbarnotification n = new statusbarnotification(
   pkg, oppkg, id, tag, callinguid, callingpid, 0, notification,
   user);

 // limit the number of notifications that any given package except the android
 // package or a registered listener can enqueue. prevents dos attacks and deals with leaks.
 if (!issystemnotification && !isnotificationfromlistener) {
  synchronized (mnotificationlist) {
   if(mnotificationsbykey.get(n.getkey()) != null) {
    // this is an update, rate limit updates only
    final float appenqueuerate = musagestats.getappenqueuerate(pkg);
    if (appenqueuerate > mmaxpackageenqueuerate) {
     musagestats.registeroverratequota(pkg);
     final long now = systemclock.elapsedrealtime();
     if ((now - mlastoverratelogtime) > min_package_overrate_log_interval) {
      slog.e(tag, "package enqueue rate is " + appenqueuerate
        + ". shedding events. package=" + pkg);
       mlastoverratelogtime = now;
     }
     return;
    }
   }

   int count = 0;
   final int n = mnotificationlist.size();
   for (int i=0; i<n; i++) {
    final notificationrecord r = mnotificationlist.get(i);
    if (r.sbn.getpackagename().equals(pkg) && r.sbn.getuserid() == userid) {
     if (r.sbn.getid() == id && textutils.equals(r.sbn.gettag(), tag)) {
      break; // allow updating existing notification
     }
     count++;
     if (count >= max_package_notifications) {
      musagestats.registerovercountquota(pkg);
      slog.e(tag, "package has already posted " + count
        + " notifications. not showing more. package=" + pkg);
      return;
     }
    }
   }
  }
 }

 // whitelist pending intents.
 if (notification.allpendingintents != null) {
  final int intentcount = notification.allpendingintents.size();
  if (intentcount > 0) {
   final activitymanagerinternal am = localservices
     .getservice(activitymanagerinternal.class);
   final long duration = localservices.getservice(
     deviceidlecontroller.localservice.class).getnotificationwhitelistduration();
   for (int i = 0; i < intentcount; i++) {
    pendingintent pendingintent = notification.allpendingintents.valueat(i);
    if (pendingintent != null) {
     am.setpendingintentwhitelistduration(pendingintent.gettarget(), duration);
    }
   }
  }
 }

 // sanitize inputs
 notification.priority = clamp(notification.priority, notification.priority_min,
   notification.priority_max);

 // setup local book-keeping
 final notificationrecord r = new notificationrecord(getcontext(), n);
 mhandler.post(new enqueuenotificationrunnable(userid, r));

 idout[0] = id;
}

@override
public void run() {
 synchronized(mnotificationlist) {
  // 省略代码
  if (notification.getsmallicon() != null) {
   statusbarnotification oldsbn = (old != null) ? old.sbn : null;
   mlisteners.notifypostedlocked(n, oldsbn);
  } else {
   slog.e(tag, "not posting notification without small icon: " + notification);
   if (old != null && !old.iscanceled) {
    mlisteners.notifyremovedlocked(n);
   }
   // attention: in a future release we will bail out here
   // so that we do not play sounds, show lights, etc. for invalid
   // notifications
   slog.e(tag, "warning: in a future release this will crash the app: " + n.getpackagename());
  }
  buzzbeepblinklocked(r);
 }
}

public void notifypostedlocked(statusbarnotification sbn, statusbarnotification oldsbn) {
 // lazily initialized snapshots of the notification.
 trimcache trimcache = new trimcache(sbn);
 for (final managedserviceinfo info: mservices) {
  boolean sbnvisible = isvisibletolistener(sbn, info);
  boolean oldsbnvisible = oldsbn != null ? isvisibletolistener(oldsbn, info) : false;
  // this notification hasn't been and still isn't visible -> ignore.
  if (!oldsbnvisible && !sbnvisible) {
   continue;
  }
  final notificationrankingupdate update = makerankingupdatelocked(info);
  // this notification became invisible -> remove the old one.
  if (oldsbnvisible && !sbnvisible) {
   final statusbarnotification oldsbnlightclone = oldsbn.clonelight();
   mhandler.post(new runnable() {
    @override
    public void run() {
     notifyremoved(info, oldsbnlightclone, update);
    }
   });
   continue;
  }
  final statusbarnotification sbntopost = trimcache.forlistener(info);
  mhandler.post(new runnable() {
   @override
   public void run() {
    notifyposted(info, sbntopost, update);
   }
  });
 }
}

private void notifyposted(final managedserviceinfo info, final statusbarnotification sbn, notificationrankingupdate rankingupdate) {
 final inotificationlistener listener = (inotificationlistener) info.service;
 statusbarnotificationholder sbnholder = new statusbarnotificationholder(sbn);
 try {
  listener.onnotificationposted(sbnholder, rankingupdate);
 } catch (remoteexception ex) {
  log.e(tag, "unable to notify listener (posted): " + listener, ex);
 }
}

public void onnotificationposted(istatusbarnotificationholder sbnholder, notificationrankingupdate update) {
 statusbarnotification sbn;
 try {
  sbn = sbnholder.get();
 } catch (remoteexception e) {
  log.w(tag, "onnotificationposted: error receiving statusbarnotification", e);
  return;
 }
 try {
  // convert icon metadata to legacy format for older clients
  createlegacyiconextras(sbn.getnotification());
  maybepopulateremoteviews(sbn.getnotification());
 } catch (illegalargumentexception e) {
  // warn and drop corrupt notification
  log.w(tag, "onnotificationposted: can't rebuild notification from " + sbn.getpackagename());
  sbn = null;
 }
 // protect subclass from concurrent modifications of (@link mnotificationkeys}.
 synchronized(mlock) {
  applyupdatelocked(update);
  if (sbn != null) {
   someargs args = someargs.obtain();
   args.arg1 = sbn;
   args.arg2 = mrankingmap;
   mhandler.obtainmessage(myhandler.msg_on_notification_posted, args).sendtotarget();
  } else {
   // still pass along the ranking map, it may contain other information
   mhandler.obtainmessage(myhandler.msg_on_notification_ranking_update, mrankingmap).sendtotarget();
  }
 }
}

public void start() {
 // 省略代码
 // set up the initial notification state.
 try {
  mnotificationlistener.registerassystemservice(mcontext,
    new componentname(mcontext.getpackagename(), getclass().getcanonicalname()),
    userhandle.user_all);
 } catch (remoteexception e) {
  log.e(tag, "unable to register notification listener", e);
 }
 // 省略代码
}

public void registerassystemservice(context context, componentname componentname,
  int currentuser) throws remoteexception {
 if (mwrapper == null) {
  mwrapper = new notificationlistenerwrapper();
 }
 msystemcontext = context;
 inotificationmanager noman = getnotificationinterface();
 mhandler = new myhandler(context.getmainlooper());
 mcurrentuser = currentuser;
 noman.registerlistener(mwrapper, componentname, currentuser);
}

private final notificationlistenerservice mnotificationlistener = new notificationlistenerservice() {
 // 省略代码
 
 @override
 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;
     // in case we don't allow child notifications, we ignore children of
     // notifications that have a summary, since we're not going to show them
     // anyway. this is true also when the summary is canceled,
     // because children are automatically canceled by noman in that case.
     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 */ );
     }
    }
   });
  }
 }
 // 省略代码
}

@override
public void addnotification(statusbarnotification notification, rankingmap ranking, entry oldentry) {
 if (debug) log.d(tag, "addnotification key=" + notification.getkey());
 mnotificationdata.updateranking(ranking);
 entry shadeentry = createnotificationviews(notification);
 if (shadeentry == null) {
  return;
 }
 boolean isheadsuped = shouldpeek(shadeentry);
 if (isheadsuped) {
  mheadsupmanager.shownotification(shadeentry);
  // mark as seen immediately
  setnotificationshown(notification);
 }
 if (!isheadsuped && notification.getnotification().fullscreenintent != null) {
  if (shouldsuppressfullscreenintent(notification.getkey())) {
   if (debug) {
    log.d(tag, "no fullscreen intent: suppressed by dnd: " + notification.getkey());
   }
  } else if (mnotificationdata.getimportance(notification.getkey()) < notificationlistenerservice.ranking.importance_max) {
   if (debug) {
    log.d(tag, "no fullscreen intent: not important enough: " + notification.getkey());
   }
  } else {
   // stop screensaver if the notification has a full-screen intent.
   // (like an incoming phone call)
   awakendreams();
   // not immersive & a full-screen alert should be shown
   if (debug) log.d(tag, "notification has fullscreenintent; sending fullscreenintent");
   try {
    eventlog.writeevent(eventlogtags.sysui_fullscreen_notification, notification.getkey());
    notification.getnotification().fullscreenintent.send();
    shadeentry.notifyfullscreenintentlaunched();
    metricslogger.count(mcontext, "note_fullscreen", 1);
   } catch (pendingintent.canceledexception e) {}
  }
 }
 // !!!
 addnotificationviews(shadeentry, ranking);
 // recalculate the position of the sliding windows and the titles.
 setaretherenotifications();
}