背景

最近在看SurfaceSyncGroup，很多代码还是很好理解的，但是其中有几处细节，可能你看的时候没有注意。
因为这个SurfaceSyncGroup名字太长，我后面都会使用SSG缩写代替。

一、跨进程使用SSG，无法支持Child SSG添加Child SSG

如果你看过代码，你应该可以发现，如果你在同一进程中使用SSG，其实是可以如下操作的。

但是如果跨进程使用，那就要注意了，可能就会有问题了，你以为你创建的是这样子关系

其实你创建的关系和你预期的不一样。

代码分析1.1

    public boolean add(ISurfaceSyncGroup surfaceSyncGroup, boolean parentSyncGroupMerge,
            @Nullable Runnable runnable) {
        //1.1如果添加的surfaceSyncGroup和当前SurfaceSyncGroup不是同一进程，就是false。
        if (isLocalBinder(surfaceSyncGroup.asBinder())) {
            boolean didAddLocalSync = addLocalSync(surfaceSyncGroup, parentSyncGroupMerge);
            if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
            }
            return didAddLocalSync;
        }

        synchronized (mLock) {
            if (!mHasWMSync) {
                // We need to add a signal into WMS since WMS will be creating a new parent
                // SurfaceSyncGroup. When the parent SSG in WMS completes, only then do we
                // notify the registered listeners that the entire SurfaceSyncGroup is complete.
                // This is because the callers don't realize that when adding a different process
                // to this SSG, it isn't actually adding to this SSG and really just creating a
                // link in WMS. Because of this, the callers would expect the complete listeners
                // to only be called when everything, including the other process's
                // SurfaceSyncGroups, have completed. Only WMS has that info so we need to send the
                // listener to WMS when we set up a server side sync.
                mSurfaceSyncGroupCompletedListener = new ISurfaceSyncGroupCompletedListener.Stub() {
                    @Override
                    public void onSurfaceSyncGroupComplete() {
                        synchronized (mLock) {
                            invokeSyncCompleteCallbacks();
                        }
                    }
                };
                // 1.1.2 然后用自己的token在WM中创建一个替身
                if (!addSyncToWm(mToken, false /* parentSyncGroupMerge */,
                        mSurfaceSyncGroupCompletedListener)) {//跳转到代码分析1.2
                    mSurfaceSyncGroupCompletedListener = null;
                    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                        Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
                    }
                    return false;
                }
                mHasWMSync = true;
            }
        }

        try {
             // 1.1.3 将token传递给子ssg，然后让子的ssg和你的替身建立关系
            surfaceSyncGroup.onAddedToSyncGroup(mToken, parentSyncGroupMerge);
        } catch (RemoteException e) {
            if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
            }
            return false;
        }

        if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
            Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
        }
        return true;
    }

1.1.1 如果添加的surfaceSyncGroup和当前SurfaceSyncGroup不是同一进程，就是false。
1.1.2 然后用自己的token在WM中创建一个替身ssg
1.1.3 将token传递给子ssg，然后让子的ssg和你的替身建立关系

代码分析1.2

当SSG1调用add(SSG2)的时候，SSG1和SSG2都会触发这个函数。
1.2.1 将自己和WM中的替身建立起关系。如果是SSG1，也就意味着和之前Root SSG建立的关系也就断开了。

    private boolean addSyncToWm(IBinder token, boolean parentSyncGroupMerge,
            @Nullable ISurfaceSyncGroupCompletedListener surfaceSyncGroupCompletedListener) {
        try {
            if (DEBUG) {
                Log.d(TAG, "Attempting to add remote sync to " + mName
                        + ". Setting up Sync in WindowManager.");
            }
            if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                Trace.asyncTraceForTrackBegin(Trace.TRACE_TAG_VIEW, mTrackName,
                        "addSyncToWm=" + token.hashCode(), hashCode());
            }
            AddToSurfaceSyncGroupResult addToSyncGroupResult = new AddToSurfaceSyncGroupResult();
            if (!WindowManagerGlobal.getWindowManagerService().addToSurfaceSyncGroup(token,
                    parentSyncGroupMerge, surfaceSyncGroupCompletedListener,
                    addToSyncGroupResult)) {
                if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                    Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
                }
                return false;
            }
           //1.2.1 将自己和WM中的替身建立起关系。如果是SSG1，也就意味着和之前Root SSG建立的关系也就断开了。
            setTransactionCallbackFromParent(addToSyncGroupResult.mParentSyncGroup,
                    addToSyncGroupResult.mTransactionReadyCallback);
        } catch (RemoteException e) {
            if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
            }
            return false;
        }
        if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
            Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
        }
        return true;
    }

最终的结果如下图

当SSG1添加到Root SSG的时候，一切还算正常
但是当SSG2添加到SSG1的时候，意外就发生了，Root SSG和SSG1就断开了连接。

二、如果SSG1添加到Root SSG之后，将SSG1添加到 SSG2，会发生什么

代码分析2.1

private void setTransactionCallbackFromParent(ISurfaceSyncGroup parentSyncGroup,
            ITransactionReadyCallback transactionReadyCallback) {
        ...
        synchronized (mLock) {
            if (mFinished) {
                finished = true;
            } else {
                // If this SurfaceSyncGroup was already added to a different SurfaceSyncGroup, we
                // need to combine everything. We can add the old SurfaceSyncGroup parent to the new
                // parent so the new parent doesn't complete until the old parent does.
                // Additionally, the old parent will not get the final transaction object and
                // instead will send it to the new parent, ensuring that any other SurfaceSyncGroups
                // from the original parent are also combined with the new parent SurfaceSyncGroup.
                // 2.1.1 如果发现SSG1有parent SSG了， 就将parent ssg（Root SSG）添加到SSG2
                if (mParentSyncGroup != null && mParentSyncGroup != parentSyncGroup) {
                    if (DEBUG) {
                        Log.d(TAG, "Trying to add to " + parentSyncGroup
                                + " but already part of sync group " + mParentSyncGroup + " "
                                + mName);
                    }
                    try {
                        //最终会跳转到代码分析 2.2
                        parentSyncGroup.addToSync(mParentSyncGroup,
                                true /* parentSyncGroupMerge */);
                    } catch (RemoteException e) {
                    }
                }

                if (DEBUG && mParentSyncGroup == parentSyncGroup) {
                    Log.d(TAG, "Added to parent that was already the parent");
                }

                // 2.1.2 保存前一个parent ssg（Root SSG）的callback。
                Consumer<Transaction> lastCallback = mTransactionReadyConsumer;
                // 2.1.3 将parent ssg 换成 SSG2
                mParentSyncGroup = parentSyncGroup;
                mTransactionReadyConsumer = (transaction) -> {
                    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                        Trace.asyncTraceForTrackBegin(Trace.TRACE_TAG_VIEW, mTrackName,
                                "Invoke transactionReadyCallback="
                                        + transactionReadyCallback.hashCode(), hashCode());
                    }
                    // 2.1.4 在SSG1完成任务的时候，虽然SSG1和Root SSG没有名义上的关系了，但是残留在Root SSG mPendingSyncs中SSG1的callback还是要触发一下的，否则会导致Root SSG无法ready。
                    lastCallback.accept(null);

                    try {
                        transactionReadyCallback.onTransactionReady(transaction);
                    } catch (RemoteException e) {
                        transaction.apply();
                    }
                    if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                        Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
                    }
                };
                addedToSyncListener = mAddedToSyncListener;
            }
        }

        // Invoke the callback outside of the lock when the SurfaceSyncGroup being added was already
        // complete.
        if (finished) {
            try {
                transactionReadyCallback.onTransactionReady(null);
            } catch (RemoteException e) {
            }
        } else if (addedToSyncListener != null) {
            addedToSyncListener.run();
        }
        if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
            Trace.asyncTraceForTrackEnd(Trace.TRACE_TAG_VIEW, mTrackName, hashCode());
        }
    }

2.1.1 如果发现SSG1有parent SSG了， 就将parent ssg（Root SSG）添加到SSG2
2.1.2 保存前一个parent ssg（Root SSG）的callback。
2.1.3 将parent ssg 换成 SSG2
2.1.4 在SSG1完成任务的时候，虽然SSG1和Root SSG没有名义上的关系了，但是残留在Root SSG mPendingSyncs中SSG1的callback还是要触发一下的，否则会导致Root SSG无法ready。

代码分析 2.2

代码分析2.1中parentSyncGroup.addToSync(mParentSyncGroup, true /* parentSyncGroupMerge */)最终会跳转到这里，关键的就是parentSyncGroupMerge为true

    public ITransactionReadyCallback createTransactionReadyCallback(boolean parentSyncGroupMerge) {
        ITransactionReadyCallback transactionReadyCallback =
                new ITransactionReadyCallback.Stub() {
                    @Override
                    public void onTransactionReady(Transaction t) {
                        synchronized (mLock) {
                            if (t != null) {
                                t.sanitize(Binder.getCallingPid(), Binder.getCallingUid());
                                // When an older parent sync group is added due to a child syncGroup
                                // getting added to multiple groups, we need to maintain merge order
                                // so the older parentSyncGroup transactions are overwritten by
                                // anything in the newer parentSyncGroup.
                                // 2.2.1 这里解释了如果为true，为了保证merge的顺序，有一些处理。
                                if (parentSyncGroupMerge) {
                                    t.merge(mTransaction);
                                }
                                mTransaction.merge(t);//p add c
                            }
                            mPendingSyncs.remove(this);
                            if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
                                Trace.instantForTrack(Trace.TRACE_TAG_VIEW, mTrackName,
                                        "onTransactionReady callback=" + hashCode());
                            }
                            checkIfSyncIsComplete();
                        }
                    }
                };
        return transactionReadyCallback;
    }

2.2.1 这里解释了如果为true，为了保证merge的顺序，有一些处理，用一个图来表示，就是如下图。

三、总结

SurfaceSyncGroup代码不是很多，但是使用时候要注意这些细节，避免发生错误，具体讲解SurfaceSyncGroup配合BBQ和BlastSyncEngine工作，我还是会选择使用图解视频的方式，给自己留个坑《王小二图解Android-SurfaceSyncGroup》