Android 9.0 SystemUI Notification

@Override
public void addContainerView(View v) {
    addView(v);
}

public void updateNotificationViews() {
    ArrayList<NotificationData.Entry> activeNotifications = mEntryManager.getNotificationData()
            .getActiveNotifications();
    ArrayList<ExpandableNotificationRow> toShow = new ArrayList<>(activeNotifications.size());
   //省略其他代码
    for (int i = 0; i < toShow.size(); i++) {
        View v = toShow.get(i);
        if (v.getParent() == null) {
            mVisualStabilityManager.notifyViewAddition(v);
            mListContainer.addContainerView(v);
        }
    }
   //省略其他代码
}

@Override
public void updateNotificationViews() {
    //省略其他代码
    mViewHierarchyManager.updateNotificationViews();
    //省略其他代码
    //这里和折叠状态栏相关
    mNotificationIconAreaController.updateNotificationIcons();
}

public void updateNotifications() {
    mNotificationData.filterAndSort();
    mPresenter.updateNotificationViews();
}

protected void addNotificationViews(NotificationData.Entry entry) {
    if (entry == null) {
        return;
    }
    // Add the expanded view and icon.
    mNotificationData.add(entry);
    tagForeground(entry.notification);
    updateNotifications();
}
//NotificationEntryManager#addNotificationViews 由 addEntry 调用了
private void addEntry(NotificationData.Entry shadeEntry) {
    boolean isHeadsUped = shouldPeek(shadeEntry);
    if (isHeadsUped) {
        mHeadsUpManager.showNotification(shadeEntry);
        // Mark as seen immediately
        setNotificationShown(shadeEntry.notification);
    }
    addNotificationViews(shadeEntry);
    mCallback.onNotificationAdded(shadeEntry);
}

@Override
public void onAsyncInflationFinished(NotificationData.Entry entry) {
    mPendingNotifications.remove(entry.key);
    // If there was an async task started after the removal, we don't want to add it back to
    // the list, otherwise we might get leaks.
    boolean isNew = mNotificationData.get(entry.key) == null;
    if (isNew && !entry.row.isRemoved()) {
        addEntry(entry);
    } else if (!isNew && entry.row.hasLowPriorityStateUpdated()) {
        mVisualStabilityManager.onLowPriorityUpdated(entry);
        mPresenter.updateNotificationViews();
    }
    entry.row.setLowPriorityStateUpdated(false);
}

@UnsupportedAppUsage
public void notifyAsUser(String tag, int id, Notification notification, UserHandle user)
{
    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 + ")");
    notification.reduceImageSizes(mContext);
    ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
    boolean isLowRam = am.isLowRamDevice();
    final Notification copy = Builder.maybeCloneStrippedForDelivery(notification, isLowRam,
            mContext);
    try {
        service.enqueueNotificationWithTag(pkg, mContext.getOpPackageName(), tag, id,
                copy, user.getIdentifier());
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

void enqueueNotificationInternal(final String pkg, final String opPkg, final int callingUid,
        final int callingPid, final String tag, final int id, final Notification notification,
        int incomingUserId) {
    //省略其他代码
    final NotificationRecord r = new NotificationRecord(getContext(), n, channel);
    r.setIsAppImportanceLocked(mRankingHelper.getIsAppImportanceLocked(pkg, callingUid));
    //省略其他代码
    mHandler.post(new EnqueueNotificationRunnable(userId, r));
}

protected class EnqueueNotificationRunnable implements Runnable {
    private final NotificationRecord r;
    private final int userId;
    EnqueueNotificationRunnable(int userId, NotificationRecord r) {
        this.userId = userId;
        this.r = r;
    };
    @Override
    public void run() {
        synchronized (mNotificationLock) {       
            // 省略其他代码
            if (mAssistants.isEnabled()) {
                mAssistants.onNotificationEnqueued(r);
                mHandler.postDelayed(new PostNotificationRunnable(r.getKey()),
                        DELAY_FOR_ASSISTANT_TIME);
            } else {
                mHandler.post(new PostNotificationRunnable(r.getKey()));
            }
        }
    }
}

protected class PostNotificationRunnable implements Runnable {
    private final String key;
    PostNotificationRunnable(String key) {
        this.key = key;
    }
    @Override
    public void run() {
        synchronized (mNotificationLock) {
            try {
                // 省略其他代码
                if (notification.getSmallIcon() != null) {
                    StatusBarNotification oldSbn = (old != null) ? old.sbn : null;
                    mListeners.notifyPostedLocked(r, old);
                    if (oldSbn == null || !Objects.equals(oldSbn.getGroup(), n.getGroup())) {
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                mGroupHelper.onNotificationPosted(
                                        n, hasAutoGroupSummaryLocked(n));
                            }
                        });
                    }
                }  // 省略其他代码
            } finally {
                // 省略其他代码
            }
        }
    }
}

@GuardedBy("mNotificationLock")
public void notifyPostedLocked(NotificationRecord r, NotificationRecord old) {
    notifyPostedLocked(r, old, true);
}
@GuardedBy("mNotificationLock")
private void notifyPostedLocked(NotificationRecord r, NotificationRecord old,
        boolean notifyAllListeners) {
    // Lazily initialized snapshots of the notification.
    StatusBarNotification sbn = r.sbn;
    StatusBarNotification oldSbn = (old != null) ? old.sbn : null;
    TrimCache trimCache = new TrimCache(sbn);
    for (final ManagedServiceInfo info : getServices()) {
        //省略其他代码
        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, null, REASON_USER_STOPPED);
                }
            });
            continue;
        }
        // Grant access before listener is notified
        final int targetUserId = (info.userid == UserHandle.USER_ALL)
                ? UserHandle.USER_SYSTEM : info.userid;
        updateUriPermissions(r, old, info.component.getPackageName(), targetUserId);
        final StatusBarNotification sbnToPost = trimCache.ForListener(info);
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                //调用NotificationManagerService#notifyPosted
                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);
    }
}

protected class NotificationListenerWrapper extends INotificationListener.Stub {
    @Override
    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());
            maybePopulatePeople(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();
            }
        }
    }
}

private final class MyHandler extends Handler {
    public static final int MSG_ON_NOTIFICATION_POSTED = 1;
    public static final int MSG_ON_NOTIFICATION_REMOVED = 2;
    public static final int MSG_ON_LISTENER_CONNECTED = 3;
    public static final int MSG_ON_NOTIFICATION_RANKING_UPDATE = 4;
    public static final int MSG_ON_LISTENER_HINTS_CHANGED = 5;
    public static final int MSG_ON_INTERRUPTION_FILTER_CHANGED = 6;
    public static final int MSG_ON_NOTIFICATION_CHANNEL_MODIFIED = 7;
    public static final int MSG_ON_NOTIFICATION_CHANNEL_GROUP_MODIFIED = 8;
    public MyHandler(Looper looper) {
        super(looper, null, false);
    }
    @Override
    public void handleMessage(Message msg) {
        if (!isConnected) {
            return;
        }
        switch (msg.what) {
            case MSG_ON_NOTIFICATION_POSTED: {
                SomeArgs args = (SomeArgs) msg.obj;
                StatusBarNotification sbn = (StatusBarNotification) args.arg1;
                RankingMap rankingMap = (RankingMap) args.arg2;
                args.recycle();
                onNotificationPosted(sbn, rankingMap);
            } break;
           //省略其他代码
        }
    }
}

public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
    onNotificationPosted(sbn);
}

@Override
public void onNotificationPosted(final StatusBarNotification sbn,
        final RankingMap rankingMap) {
    if (DEBUG) Log.d(TAG, "onNotificationPosted: " + sbn);
    if (sbn != null && !onPluginNotificationPosted(sbn, rankingMap)) {
        mPresenter.getHandler().post(() -> {
            //省略其他代码
            if (isUpdate) {
                mEntryManager.updateNotification(sbn, rankingMap);
            } else {
                mEntryManager.addNotification(sbn, rankingMap);
            }
        });
    }
}

@Override
public void addNotification(StatusBarNotification notification,
        NotificationListenerService.RankingMap ranking) {
    try {
        addNotificationInternal(notification, ranking);
    } catch (InflationException e) {
        handleInflationException(notification, e);
    }
}
private void addNotificationInternal(StatusBarNotification notification,
        NotificationListenerService.RankingMap ranking) throws InflationException {
    String key = notification.getKey();
    if (DEBUG) Log.d(TAG, "addNotification key=" + key);
    mNotificationData.updateRanking(ranking);
    //继续看 createNotificationViews
    NotificationData.Entry shadeEntry = createNotificationViews(notification);
    //省略其他代码
}
protected NotificationData.Entry createNotificationViews(StatusBarNotification sbn)
        throws InflationException {
    if (DEBUG) {
        Log.d(TAG, "createNotificationViews(notification=" + sbn);
    }
    NotificationData.Entry entry = new NotificationData.Entry(sbn);
    Dependency.get(LeakDetector.class).trackInstance(entry);
    entry.createIcons(mContext, sbn);
    // Construct the expanded view.
    inflateViews(entry, mListContainer.getViewParentForNotification(entry));
    return entry;
}

private void inflateViews(NotificationData.Entry entry, ViewGroup parent) {
    PackageManager pmUser = StatusBar.getPackageManagerForUser(mContext,
            entry.notification.getUser().getIdentifier());
    final StatusBarNotification sbn = entry.notification;
    if (entry.row != null) {
        entry.reset();
        updateNotification(entry, pmUser, sbn, entry.row);
    } else {
        //来通知会走到这里
        new RowInflaterTask().inflate(mContext, parent, entry,
                row -> {
                    bindRow(entry, pmUser, sbn, row);
                    updateNotification(entry, pmUser, sbn, row);
                });
    }
}

public void inflate(Context context, ViewGroup parent, NotificationData.Entry entry,
        RowInflationFinishedListener listener) {
    if (TRACE_ORIGIN) {
        mInflateOrigin = new Throwable("inflate requested here");
    }
    mListener = listener;
    AsyncLayoutInflater inflater = new AsyncLayoutInflater(context);
    mEntry = entry;
    entry.setInflationTask(this);
    //这里是Notification布局文件
    inflater.inflate(R.layout.status_bar_notification_row, parent, this);
}

@Override
public void onInflateFinished(View view, int resid, ViewGroup parent) {
    if (!mCancelled) {
        try {
            mEntry.onInflationTaskFinished();
            //1. 调 RowInflationFinishedListener#onInflationFinished
            mListener.onInflationFinished((ExpandableNotificationRow) view);
        } catch (Throwable t) {
            if (mInflateOrigin != null) {
                Log.e(TAG, "Error in inflation finished listener: " + t, mInflateOrigin);
                t.addSuppressed(mInflateOrigin);
            }
            throw t;
        }
    }
}
public interface RowInflationFinishedListener {
    //2. 在 NotificationEntryManager#row 实现
    void onInflationFinished(ExpandableNotificationRow row);
}

public void updateNotification(NotificationData.Entry entry) {
    mEntry = entry;
    mStatusBarNotification = entry.notification;
    mNotificationInflater.inflateNotificationViews();
    cacheIsSystemNotification();
}

@VisibleForTesting
void inflateNotificationViews(int reInflateFlags) {
    if (mRow.isRemoved()) {
       return;
    }
    StatusBarNotification sbn = mRow.getEntry().notification;
    AsyncInflationTask task = new AsyncInflationTask(sbn, reInflateFlags, mRow,
            mIsLowPriority,
            mIsChildInGroup, mUsesIncreasedHeight, mUsesIncreasedHeadsUpHeight, mRedactAmbient,
            mCallback, mRemoteViewClickHandler);
    if (mCallback != null && mCallback.doInflateSynchronous()) {
        task.onPostExecute(task.doInBackground());
    } else {
        task.execute();
    }
}

public static class AsyncInflationTask extends AsyncTask<Void, Void, InflationProgress>
        implements InflationCallback, InflationTask {
       //省略其他代码
    @Override
    protected InflationProgress doInBackground(Void... params) {
        //省略其他代码
    }
    @Override
    protected void onPostExecute(InflationProgress result) {
        if (mError == null) {
            mCancellationSignal = apply(result, mReInflateFlags, mRow, mRedactAmbient,
                    mRemoteViewClickHandler, this);
        } else {
            handleError(mError);
        }
    }
}

@VisibleForTesting
static void applyRemoteView(final InflationProgress result,
        final int reInflateFlags, int inflationId,
        final ExpandableNotificationRow row,
        final boolean redactAmbient, boolean isNewView,
        RemoteViews.OnClickHandler remoteViewClickHandler,
        @Nullable final InflationCallback callback, NotificationData.Entry entry,
        NotificationContentView parentLayout, View existingView,
        NotificationViewWrapper existingWrapper,
        final HashMap<Integer, CancellationSignal> runningInflations,
        ApplyCallback applyCallback) {
    RemoteViews newContentView = applyCallback.getRemoteView();
    //省略其他代码
    RemoteViews.OnViewAppliedListener listener
            = new RemoteViews.OnViewAppliedListener() {
        @Override
        public void onViewApplied(View v) {
            if (isNewView) {
                v.setIsRootNamespace(true);
                applyCallback.setResultView(v);
            } else if (existingWrapper != null) {
                existingWrapper.onReinflated();
            }
            runningInflations.remove(inflationId);
            finishIfDone(result, reInflateFlags, runningInflations, callback, row,
                    redactAmbient);
        }
        //
    };
    CancellationSignal cancellationSignal;
    if (isNewView) {
        //调用RemoteViews#applyAsync，最终回调了上面的onViewApplied方法。
        cancellationSignal = newContentView.applyAsync(
                result.packageContext,
                parentLayout,
                EXECUTOR,
                listener,
                remoteViewClickHandler);
    }//省略其他代码
    runningInflations.put(inflationId, cancellationSignal);
}

@Override
public void onAsyncInflationFinished(NotificationData.Entry entry) {
    mPendingNotifications.remove(entry.key);
    // If there was an async task started after the removal, we don't want to add it back to
    // the list, otherwise we might get leaks.
    boolean isNew = mNotificationData.get(entry.key) == null;
    if (isNew && !entry.row.isRemoved()) {
        addEntry(entry);
    } else if (!isNew && entry.row.hasLowPriorityStateUpdated()) {
        mVisualStabilityManager.onLowPriorityUpdated(entry);
        mPresenter.updateNotificationViews();
    }
    entry.row.setLowPriorityStateUpdated(false);
}

<com.android.systemui.statusbar.AlphaOptimizedFrameLayout
    android:id="@+id/notification_icon_area"
    android:layout_width="0dp"
    android:layout_height="match_parent"
    android:layout_weight="1"
    android:orientation="horizontal"
    android:clipChildren="false"/>

//NotificationIconAreaController 初始化
mNotificationIconAreaController = SystemUIFactory.getInstance()
        .createNotificationIconAreaController(context, this);
inflateShelf();
mNotificationIconAreaController.setupShelf(mNotificationShelf);
mStackScroller.setIconAreaController(mNotificationIconAreaController);
Dependency.get(DarkIconDispatcher.class).addDarkReceiver(mNotificationIconAreaController);
FragmentHostManager.get(mStatusBarWindow)
        .addTagListener(CollapsedStatusBarFragment.TAG, (tag, fragment) -> {
            CollapsedStatusBarFragment statusBarFragment =
                    (CollapsedStatusBarFragment) fragment;
            statusBarFragment.initNotificationIconArea(mNotificationIconAreaController);
            //省略其他代码
        }).getFragmentManager()
        .beginTransaction()
        .replace(R.id.status_bar_container, new CollapsedStatusBarFragment(),
                CollapsedStatusBarFragment.TAG)
        .commit();

public void initNotificationIconArea(NotificationIconAreaController
        notificationIconAreaController) {
    ViewGroup notificationIconArea = mStatusBar.findViewById(R.id.notification_icon_area);
    mNotificationIconAreaInner =
            notificationIconAreaController.getNotificationInnerAreaView();
    if (mNotificationIconAreaInner.getParent() != null) {
        ((ViewGroup) mNotificationIconAreaInner.getParent())
                .removeView(mNotificationIconAreaInner);
    }
    notificationIconArea.addView(mNotificationIconAreaInner);
    // Default to showing until we know otherwise.
    showNotificationIconArea(false);
}

@Override
public void updateNotificationViews() {
    // 省略其他代码
    mNotificationIconAreaController.updateNotificationIcons();
}

public void updateNotificationIcons() {
    updateStatusBarIcons();
    updateShelfIcons();
    updateHasShelfIconsWhenFullyDark();
    applyNotificationIconsTint();
}
public void updateStatusBarIcons() {
    updateIconsForLayout(entry -> entry.icon, mNotificationIcons,
            false /* showAmbient */, true /* hideDismissed */, true /* hideRepliedMessages */);
}
private void updateIconsForLayout(Function<NotificationData.Entry, StatusBarIconView> function,
        NotificationIconContainer hostLayout, boolean showAmbient, boolean hideDismissed,
        boolean hideRepliedMessages) {
    ArrayList<StatusBarIconView> toShow = new ArrayList<>(
            mNotificationScrollLayout.getChildCount());
    //省略其他代码
    final FrameLayout.LayoutParams params = generateIconLayoutParams();
    for (int i = 0; i < toShow.size(); i++) {
        StatusBarIconView v = toShow.get(i);
        // The view might still be transiently added if it was just removed and added again
        hostLayout.removeTransientView(v);
        if (v.getParent() == null) {
            if (hideDismissed) {
                v.setOnDismissListener(mUpdateStatusBarIcons);
            }
            hostLayout.addView(v, i, params);
        }
    }
    hostLayout.setChangingViewPositions(true);
    // Re-sort notification icons
    final int childCount = hostLayout.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View actual = hostLayout.getChildAt(i);
        StatusBarIconView expected = toShow.get(i);
        if (actual == expected) {
            continue;
        }
        hostLayout.removeView(expected);
        hostLayout.addView(expected, i);
    }
    hostLayout.setChangingViewPositions(false);
    hostLayout.setReplacingIcons(null);
}