Android应用程序UI硬件加速渲染的动画执行过程分析

在分析AnimatorManager类的成员函数addAnimator的实现之前，我们首先了解AnimatorManager类的三个成员变量：

1. mParent，它描述的是一个RenderNode对象，该RenderNode对象与当前正在处理的AnimatorManager对象关联。

2. mNewAnimators，它描述的是一个Vector，该Vector用来保存新增加的动画。

3. mAnimators，它描述的也是一个Vector。在绘制应用程序窗口的下一帧之前，新增加的动画会从成员变量mNewAnimators描述的Vector转移到成员变量mAnimators描述的Vector中去等待处理。

AnimatorManager类的成员函数addAnimator首先是增加参数animator描述的一个BaseRenderNodeAnimator对象的引用计数，因为后面要将它添加成员变量mNewAnimators描述的一个Vector中去。此外，AnimatorManager类的成员函数addAnimator还会调用参数animator描述的一个BaseRenderNodeAnimator对象的成员函数attach将该BaseRenderNodeAnimator对象与要显示动画的Render Node进行关联。

这一步执行完成之后，我们就将要显示的动画设置到目标View关联的一个RenderNode对象内部的一个AnimatorManager对象中去了。返回到Java层的RenderNode类的成员函数addAniamtor中，接下来我们继续分析ViewRootImpl类的成员函数registerAnimatingRenderNode的实现，以便可以了解Render Thread知道有Render Node有新的动画需要显示的过程。

ViewRootImpl类的成员函数registerAnimatingRenderNode的实现如下所示：

public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
    ......

    public void registerAnimatingRenderNode(RenderNode animator) {
        if (mAttachInfo.mHardwareRenderer != null) {
            mAttachInfo.mHardwareRenderer.registerAnimatingRenderNode(animator);
        } else {
            if (mAttachInfo.mPendingAnimatingRenderNodes == null) {
                mAttachInfo.mPendingAnimatingRenderNodes = new ArrayList();
            }
            mAttachInfo.mPendingAnimatingRenderNodes.add(animator);
        }
    }

    ......
}

当ViewRootImpl类的成员变量mAttachInfo指向的一个AttachInfo对象的成员变量mHardwareRenderer的值不等于null的时候，它指向的是一个ThreadedRenderer对象。在这种情况下，ViewRootImpl类的成员函数registerAnimatingRenderNode会直接调用该ThreadedRenderer对象的成员函数registerAnimatingRenderNode将参数animator描述的一个Render Node注册到Render Thread中去，以便Render Thread知道哪些Rendr Node有新的动画需要显示。

另一方面，当ViewRootImpl类的成员变量mAttachInfo指向的一个AttachInfo对象的成员变量mHardwareRenderer的值等于null的时候，这意味着应用程序窗口使用软件渲染或者使用硬件加速渲染但是硬件加速渲染环境还没有初始化好。在这两种情况下，都是先将参数animator描述的Render Node保存在成员变量mAttachInfo指向的一个AttachInfo对象的成员变量mPendingAnimatingRenderNodes描述的一个列表中等待处理。

从前面Android应用程序UI硬件加速渲染的Display List构建过程分析一文可以知道，当使用硬件加速渲染时，应用程序窗口的渲染是从调用ThreadedRenderer类的成员函数draw开始的，它的实现如下所示：

public class ThreadedRenderer extends HardwareRenderer {  
    ......  
  
    @Override  
    void draw(View view, AttachInfo attachInfo, HardwareDrawCallbacks callbacks) {  
        ......  
  
        updateRootDisplayList(view, callbacks);  
        ......  
  
        if (attachInfo.mPendingAnimatingRenderNodes != null) {  
            final int count = attachInfo.mPendingAnimatingRenderNodes.size();  
            for (int i = 0; i < count; i++) {  
                registerAnimatingRenderNode(  
                        attachInfo.mPendingAnimatingRenderNodes.get(i));  
            }  
            attachInfo.mPendingAnimatingRenderNodes.clear();  
            // We don't need this anymore as subsequent calls to  
            // ViewRootImpl#attachRenderNodeAnimator will go directly to us.  
            attachInfo.mPendingAnimatingRenderNodes = null;  
        }  
  
        int syncResult = nSyncAndDrawFrame(mNativeProxy, frameTimeNanos,  
                recordDuration, view.getResources().getDisplayMetrics().density);  
        if ((syncResult & SYNC_INVALIDATE_REQUIRED) != 0) {  
            attachInfo.mViewRootImpl.invalidate();  
        }  
    }  
  
    ......  
}

ThreadedRenderer类的成员函数draw在调用成员函数updateRootDisplayList构建应用程序窗口的Display List之后，并且调用成员函数nSyncAndDrawFrame渲染应用程序窗口的Display List之前，会调用成员函数registerAnimatingRenderNode处理保存在上面提到的AttachInfo对象的成员变量mPendingAnimatingRenderNodes描述的一个列表中的每一个Render Node。

ThreadedRenderer类的成员函数registerAnimatingRenderNode的实现如下所示：

public class ThreadedRenderer extends HardwareRenderer {  
    ......  
  
    @Override
    void registerAnimatingRenderNode(RenderNode animator) {
        nRegisterAnimatingRenderNode(mRootNode.mNativeRenderNode, animator.mNativeRenderNode);
    }
  
    ......  
}  

ThreadedRenderer类的成员函数registerAnimatingRenderNode调用另外一个成员函数nRegisterAnimatingRenderNode将参数animator描述的一个Render Node注册到Render Thread中去。

ThreadedRenderer类的成员函数nRegisterAnimatingRenderNode是一个JNI函数，由Native层的函数android_view_ThreadedRenderer_registerAnimatingRenderNode实现，如下所示：

static void android_view_ThreadedRenderer_registerAnimatingRenderNode(JNIEnv* env, jobject clazz,
        jlong rootNodePtr, jlong animatingNodePtr) {
    RootRenderNode* rootRenderNode = reinterpret_cast(rootNodePtr);
    RenderNode* animatingNode = reinterpret_cast(animatingNodePtr);
    rootRenderNode->attachAnimatingNode(animatingNode);
}

参数rootNodePtr指向的是一个RootRenderNode对象，该RootRenderNode对象描述的是应用程序窗口的Root Render Node，这里主要就是将参数animatorNodePtr描述的一个Render Node注册在上述的RootRenderNode对象的内部，这是通过调用RootRenderNode类的成员函数attachAnimatingNode实现的。

RootRenderNode类的成员函数attachAnimatingNode的实现如下所示：

class RootRenderNode : public RenderNode, ErrorHandler {
public:
    ......

    void attachAnimatingNode(RenderNode* animatingNode) {
        mPendingAnimatingRenderNodes.push_back(animatingNode);
    }

    ......
private:
    ......
    std::vector< sp > mPendingAnimatingRenderNodes;
};

RootRenderNode类的成员函数attachAnimatingNode将参数animatingNode描述的一个Render Node保存成员变量mPendingAnimatingRenderNodes描述的一个Vector中。保在这个Vector中的Render Node将会在应用程序窗口的下一帧被渲染时得到处理。

从前面Android应用程序UI硬件加速渲染的Display List渲染过程分析一文可以知道，Render Thread在渲染应用程序窗口的下一帧时，会调用CanvasContext类的成员函数prepareTree将应用程序窗口的Display List从Main Thread同步到Render Thread，如下所示：

void CanvasContext::prepareTree(TreeInfo& info) {
    ......

    info.renderer = mCanvas;
    ......

    mAnimationContext->startFrame(info.mode);
    mRootRenderNode->prepareTree(info);
    mAnimationContext->runRemainingAnimations(info);

    ......

    int runningBehind = 0;
    // TODO: This query is moderately expensive, investigate adding some sort
    // of fast-path based off when we last called eglSwapBuffers() as well as
    // last vsync time. Or something.
    mNativeWindow->query(mNativeWindow.get(),
            NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind);
    info.out.canDrawThisFrame = !runningBehind;

    if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
        if (!info.out.requiresUiRedraw) {
            // If animationsNeedsRedraw is set don't bother posting for an RT anim
            // as we will just end up fighting the UI thread.
            mRenderThread.postFrameCallback(this);
        }
    }
}

CanvasContext类的成员函数prepareTree的详细实现分析可以参考前面Android应用程序UI硬件加速渲染的Display List渲染过程分析一文，这里我们主要关注与动画相关的两个操作：

1. 第一个操作是在调用RenderNode类的成员函数prepareTree同步应用程序窗口的Display List之前，调用成员变量mAnimationContext描述的一个AnimationContext对象的成员函数startFrame执行一些动画显示的准备工作。

2. 第二个操作是在调用RenderNode类的成员函数prepareTree同步应用程序窗口的Display List之后，调用成员变量mAnimationContext描述的一个AnimationContext对象的成员函数runRemainingAnimations更新剩下的还未完成的动画。

接下来我们就分别分析这两个操作的执行过程，即分析AnimationContext类的成员函数startFrame和runRemainingAnimations的实现。不过，在分析这两个函数的实现之前，我们首先要了解CanvasContext类的成员变量mAnimationContext的初始化过程。

从前面Android应用程序UI硬件加速渲染环境初始化过程分析一文可以知道，在Android应用程序的硬件加速渲染环境的初始化过程中，会创建一个RenderProxy对象，如下所示：

static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
        jboolean translucent, jlong rootRenderNodePtr) {
    RootRenderNode* rootRenderNode = reinterpret_cast(rootRenderNodePtr);
    ContextFactoryImpl factory(rootRenderNode);
    return (jlong) new RenderProxy(translucent, rootRenderNode, &factory);
}

在调用RenderProxy类的构造函数创建一个RenderProxy对象的时候，传递进去的第三个参数是一个ContextFactoryImpl对象。

我们继续看RenderProxy类的构造函数的实现，如下所示：

CREATE_BRIDGE4(createContext, RenderThread* thread, bool translucent,
        RenderNode* rootRenderNode, IContextFactory* contextFactory) {
    return new CanvasContext(*args->thread, args->translucent,
            args->rootRenderNode, args->contextFactory);
}

RenderProxy::RenderProxy(bool translucent, RenderNode* rootRenderNode, IContextFactory* contextFactory)
        : mRenderThread(RenderThread::getInstance())
        , mContext(0) {
    SETUP_TASK(createContext);
    args->translucent = translucent;
    args->rootRenderNode = rootRenderNode;
    args->thread = &mRenderThread;
    args->contextFactory = contextFactory;
    mContext = (CanvasContext*) postAndWait(task);
    mDrawFrameTask.setContext(&mRenderThread, mContext);
}

RenderProxy类的构造函数首先是向Render Thread的Task Queue发送一个Task，并且等待该Task执行完成。上述Task在执行的时候，会调用由宏CREATE_BRIDGE4声明的函数createContext。该函数所做的事情就是创建一个CanvasContext对象。该CanvasContext对象最终保存在RenderProxy类的成员变量mContext中。

在调用CanvasContext类的构造函数创建一个CanvasContext对象的时候，传递进去的第四个参数就是在前面分析的函数android_view_ThreadedRenderer_createProxy声明的一个ContextFactoryImpl对象。

CanvasContext类的构造函数的实现如下所示：

CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
        RenderNode* rootRenderNode, IContextFactory* contextFactory)
        :...... {
    mAnimationContext = contextFactory->createAnimationContext(mRenderThread.timeLord());
    ......
}

从这里就可以看出，CanvasContext的成员变量mAnimationContext指向的一个AnimationContext对象是由参数contextFactory描述的一个IContextFactory接口的成员函数createAnimationContext创建的。

从前面的调用过程可以知道，参数contextFactory指向的实际上是一个ContextFactoryImpl对象，它的成员函数createAnimationContext的实现如下所示：

class ContextFactoryImpl : public IContextFactory {
public:
    ContextFactoryImpl(RootRenderNode* rootNode) : mRootNode(rootNode) {}

    virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) {
        return new AnimationContextBridge(clock, mRootNode);
    }

private:
    RootRenderNode* mRootNode;
};

ContextFactoryImpl类的成员函数createAnimationContext创建的是一个AnimationContextBridge对象，由此就可见，CanvasContext的成员变量mAnimationContext实际指向的一个AnimationContextBridge对象。

明白了这一点之后，回到前面分析的CanvasContext类的成员函数prepareTree中，它在同步应用程序窗口的Display List之前，调用了AnimationContextBridge类的成员函数startFrame执行一些动画显示的准备工作。

AnimationContextBridge类的成员函数startFrame的实现如下所示：

class AnimationContextBridge : public AnimationContext {
public:
    ......

    // Marks the start of a frame, which will update the frame time and move all
    // next frame animations into the current frame
    virtual void startFrame(TreeInfo::TraversalMode mode) {
        if (mode == TreeInfo::MODE_FULL) {
            mRootNode->doAttachAnimatingNodes(this);
        }
        AnimationContext::startFrame(mode);
    }

    ......
private:
    sp mRootNode;
    ......
};

参数mode的值等于TreeInfo::MODE_FULL，表示目前Render Thread是处于同步应用程序窗口的Display List的过程中。在这种情况下，AnimationContextBridge类的成员函数startFrame执行两个操作：

1. 调用成员变量mRootNode描述的一个RootRenderNode对象的成员函数doAttachAnimatingNodes处理它内部保存的有动画显示的Render Node。

2. 调用父类AnimationContext的成员函数startFrame继续执行一些动画显示之前的准备工作。

接下来，我们就先分析RootRenderNode类的成员函数doAttachAnimatingNodes的实现，再分析AnimationContext类的成员函数startFrame的实现。

RootRenderNode类的成员函数doAttachAnimatingNodes的实现如下所示：

class RootRenderNode : public RenderNode, ErrorHandler {
public:
    ......

    void doAttachAnimatingNodes(AnimationContext* context) {
        for (size_t i = 0; i < mPendingAnimatingRenderNodes.size(); i++) {
            RenderNode* node = mPendingAnimatingRenderNodes[i].get();
            context->addAnimatingRenderNode(*node);
        }
        mPendingAnimatingRenderNodes.clear();
    }

private:
    ......
    std::vector< sp > mPendingAnimatingRenderNodes;
};

RootRenderNode类的成员函数doAttachAnimatingNodes遍历保存在成员变量mPendingAnimatingRenderNodes描述的一个Vector中的每一个RenderNode对象，并且分别调用参数context描述的一个AnimationContextBridge对象的成员函数addAnimatingRenderNode对它们进行处理。

AnimationContextBridge类的成员函数addAnimatingRenderNode是从父类AnimationContext继承下来的，它的实现如下所示：

void AnimationContext::addAnimatingRenderNode(RenderNode& node) {
    if (!node.animators().hasAnimationHandle()) {
        AnimationHandle* handle = new AnimationHandle(node, *this);
        addAnimationHandle(handle);
    }
}

参数node指向的是一个RenderNode对象，调用它的成员函数animators可以获得它内部的一个AnimatorManager对象。如果该AnimatorManager对象还没有设置过一个AnimationHandle对象，那么AnimationContext类的成员函数addAnimatingRenderNode就为其设置一个AnimationHandle对象，并且这个AnimationHandle对象会通过AnimationContext类的成员函数addAnimationHandle保存在当前正在处理的一个AnimationContext对象的内部。

AnimationContext类的成员函数addAnimationHandle的实现如下所示：

void AnimationContext::addAnimationHandle(AnimationHandle* handle) {
    handle->insertAfter(&mNextFrameAnimations);
}

AnimationContext类的成员函数addAnimationHandle所做的事情就是将参数handle描述的一个AnimationHandle对象插入成员变量mNextFrameAnimations描述的一个AnimationHandle列表中。

由此我们就可以推断出，只要AnimationContext类的成员变量NextFrameAnimations描述的一个AnimationHandle列表不为空，那么就意味着Render Thread在渲染应用程序窗口的下一帧的时候，有Render Node需要显示动画。

这一步执先完成之后，返回到AnimationContextBridge类的成员函数startFrame中，接下来它所做的事情就是调用父类AnimationContext的成员函数startFrame继续执行一些动画显示之前的准备工作。

AnimationContext的成员函数startFrame的实现如下所示：

void AnimationContext::startFrame(TreeInfo::TraversalMode mode) {
    ......
    AnimationHandle* head = mNextFrameAnimations.mNextHandle;
    if (head) {
        mNextFrameAnimations.mNextHandle = NULL;
        mCurrentFrameAnimations.mNextHandle = head;
        head->mPreviousHandle = &mCurrentFrameAnimations;
    }
    ......
}

AnimationContext的成员函数startFrame所做的事情就是将成员变量mNextFrameAnimations描述的一个AnimationHandle列表转移到另外一个成员变量mCurrentFrameAnimations中。

由此我们就可以推断出，只要AnimationContext类的成员变量mCurrentFrameAnimations描述的一个AnimationHandle列表不为空，那么就意味着Render Thread在渲染应用程序窗口的当前帧的时候，有Render Node需要显示动画。

这一步执行完成之后，返回到CanvasContext类的成员函数prepareTree中，当它同步同步应用程序窗口的Display List之后，就调用成员变量mAnimationContext描述的一个AnimationContextBridge对象的成员函数runRemainingAnimations更新剩下的还未完成的动画。

AnimationContextBridge类的成员函数runRemainingAnimations的实现如下所示：

class AnimationContextBridge : public AnimationContext {
public:
    ......

    // Runs any animations still left in mCurrentFrameAnimations
    virtual void runRemainingAnimations(TreeInfo& info) {
        AnimationContext::runRemainingAnimations(info);
        ......
    }

    ......
};

AnimationContextBridge类的成员函数runRemainingAnimations主要是通过调用父类AnimationContext的成员函数runRemainingAnimations更新剩下的还未完成的动画。

AnimationContext类的成员函数runRemainingAnimations的实现如下所示：

void AnimationContext::runRemainingAnimations(TreeInfo& info) {
    while (mCurrentFrameAnimations.mNextHandle) {
        AnimationHandle* current = mCurrentFrameAnimations.mNextHandle;
        AnimatorManager& animators = current->mRenderNode->animators();
        animators.pushStaging();
        animators.animateNoDamage(info);
        ......
    }
}

前面提到，应用程序窗口当前帧要显示动画都记录在AnimationContext类的成员mCurrentFrameAnimations描述的一个AnimationHandle列表中。因此，AnimationContext类的成员函数runRemainingAnimations就遍历这个列表中的每一个AnimationHandle，并且获得与其关联的一个AnimatorManager。有了这些AnimatorManager之的，就可以调用它们的成员函数pushStaging和animateNoDamage来执行动画，其实就是计算动画的下一帧参数，以便应用在目标Render Node上。

AnimatorManager类的成员函数pushStaging的实现如下所示：

void AnimatorManager::pushStaging() {
    if (mNewAnimators.size()) {
        ......
        move_all(mNewAnimators, mAnimators);
    }
    for (vector::iterator it = mAnimators.begin(); it != mAnimators.end(); it++) {
        (*it)->pushStaging(mAnimationHandle->context());
    }
}

void AnimatorManager::animateNoDamage(TreeInfo& info) {
    if (!mAnimators.size()) return;

    animateCommon(info);
}

uint32_t AnimatorManager::animateCommon(TreeInfo& info) {
    AnimateFunctor functor(info, mAnimationHandle->context());
    std::vector< BaseRenderNodeAnimator* >::iterator newEnd;
    newEnd = std::remove_if(mAnimators.begin(), mAnimators.end(), functor);
    mAnimators.erase(newEnd, mAnimators.end());
    mAnimationHandle->notifyAnimationsRan();
    return functor.dirtyMask;
}

class AnimateFunctor {
public:
    AnimateFunctor(TreeInfo& info, AnimationContext& context)
            : dirtyMask(0), mInfo(info), mContext(context) {}

    bool operator() (BaseRenderNodeAnimator* animator) {
        dirtyMask |= animator->dirtyMask();
        bool remove = animator->animate(mContext);
        if (remove) {
            animator->decStrong(0);
        } else {
            if (animator->isRunning()) {
                mInfo.out.hasAnimations = true;
            }
            if (CC_UNLIKELY(!animator->mayRunAsync())) {
                mInfo.out.requiresUiRedraw = true;
            }
        }
        return remove;
    }

    uint32_t dirtyMask;

private:
    TreeInfo& mInfo;
    AnimationContext& mContext;
};

void AnimationHandle::notifyAnimationsRan() {
    removeFromList();
    if (mRenderNode->animators().hasAnimators()) {
        mContext.addAnimationHandle(this);
    } else {
        release();
    }
}

public class RenderNodeAnimator extends Animator {
    ......

    @Override
    public void setAllowRunningAsynchronously(boolean mayRunAsync) {
        checkMutable();
        nSetAllowRunningAsync(mNativePtr.get(), mayRunAsync);
    }

    ......
}

static void setAllowRunningAsync(JNIEnv* env, jobject clazz, jlong animatorPtr, jboolean mayRunAsync) {
    BaseRenderNodeAnimator* animator = reinterpret_cast(animatorPtr);
    animator->setAllowRunningAsync(mayRunAsync);
}

class BaseRenderNodeAnimator : public VirtualLightRefBase {
    ......
public:
    ......

    ANDROID_API void setAllowRunningAsync(bool mayRunAsync) {
        mMayRunAsync = mayRunAsync;
    }
    bool mayRunAsync() { return mMayRunAsync; }

    ......
};

void CanvasContext::prepareTree(TreeInfo& info) {
    ......

    info.renderer = mCanvas;
    ......

    mAnimationContext->startFrame(info.mode);
    mRootRenderNode->prepareTree(info);
    mAnimationContext->runRemainingAnimations(info);

    ......

    if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
        if (!info.out.requiresUiRedraw) {
            // If animationsNeedsRedraw is set don't bother posting for an RT anim
            // as we will just end up fighting the UI thread.
            mRenderThread.postFrameCallback(this);
        }
    }
}

void CanvasContext::doFrame() {
    ......

    TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState());
    prepareTree(info);
    if (info.out.canDrawThisFrame) {
        draw();
    }
}