title: Android動畫實現(xiàn)繪制原理
date: 2016-10-05 15:00
本文發(fā)表于KuTear's Blog,轉(zhuǎn)載請注明
讀前補充
關(guān)于標記位在Android運用的是非常的多，簡單的說就是使用二進制中的一位表示一個狀態(tài),下面簡單的舉個栗子。
private int flag = 0;
private static final int NEED_DRAW = 0x1； //0001; //表示需要繪制
private static final int HAS_ANIMATION = 0x2; //0010;//表示有動畫
private static final int HAS_BACKGROUND = 0x4 //0100;//有背景色
private static final int HAS_FORGROUND = 0x8 //1000;//有前景色
void action(){
if(flag & NEED_DRAW == NEED_DRAW){
draw();
}
}
void draw(){
if(flag & HAS_FORGROUND == HAS_FORGROUND){
drawForground();
}
...
}
void clearDrawFlag(){
flag &= ~NEED_DRAW;
}
void setDrawFlag(){
flag |= NEED_DRAW;
}
上面的思維在View中使用的比較的多，我們只要記住flag & HAS_FORGROUND == HAS_FORGROUND就表示flag存在HAS_FORGROUND標記位，另外，也可以一次判斷多個標記的存在情況。
if(flag & (HAS_FORGROUND | HAS_BACKGROUND) == (HAS_FORGROUND | HAS_BACKGROUND)){
//前景和背景同時存在
}
View Animation繪制的流程
在View中,我們知道View的繪制過程是從函數(shù)draw(canvas)開始，下面我們來分析一下該函數(shù)，根據(jù)它的注釋部分，我們很容易得到簡化版的邏輯代碼。
//View.java
@CallSuper
public void draw(Canvas canvas) {
// Step 1, draw the background, if needed
drawBackground(canvas);
// skip step 2 & 5 if possible (common case)
// Step 3, draw the content 非透明才繪制
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);
}
我們知道，View樹的頂層是DecorView,它是FrameLayout的子類，繪制是從根節(jié)點開始(RootViewImpl中的dispatchDraw())，根據(jù)上面的代碼會分發(fā)繪制到子View,有子View一定是ViewGroup的子類，所以看看ViewGroup的dispatchDraw(canvas)，View的該函數(shù)是個空實現(xiàn)，因為根本就不需要分發(fā)繪制。
//ViewGroup.java
@Override
protected void dispatchDraw(Canvas canvas) {
//balabala
for (int i = 0; i < childrenCount; i++) {
while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
final View transientChild = mTransientViews.get(transientIndex);
if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
transientChild.getAnimation() != null) {
more |= drawChild(canvas, transientChild, drawingTime);
}
transientIndex++;
if (transientIndex >= transientCount) {
transientIndex = -1;
}
}
int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
final View child = (preorderedList == null)
? children[childIndex] : preorderedList.get(childIndex);
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
//balabala
}
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}
這里代碼好多，選擇性的看吧，反正邏輯就是調(diào)用了函數(shù)drawChild(),然而 drawChild()就是直接調(diào)用child的draw(Canvas canvas, ViewGroup parent, long drawingTime)函數(shù),這里就是把繪制分發(fā)到子View，使得整個View Tree得以繪制。OK,我們接著看到底是怎么繪制的。
//View.java
boolean draw(Canvas canvas, ViewGroup parent, long drawingTime){
boolean drawingWithRenderNode = mAttachInfo != null
&& mAttachInfo.mHardwareAccelerated
&& hardwareAcceleratedCanvas;
final Animation a = getAnimation();
if (a != null) {
//如果有動畫就在這個函數(shù)內(nèi)部請求重繪，return True if the animation is still running
more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
concatMatrix = a.willChangeTransformationMatrix();
if (concatMatrix) {
mPrivateFlags3 |= PFLAG3_VIEW_IS_ANIMATING_TRANSFORM;
}
transformToApply = parent.getChildTransformation();
}
if(drawingWithRenderNode){
renderNode = updateDisplayListIfDirty(); //其內(nèi)部調(diào)用draw(canvas)
}
return more;
}
private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
Animation a, boolean scalingRequired) {
//t為根據(jù)動畫產(chǎn)生的Transformation{mAlpha,mMatrix}，可以控制基本的動畫
boolean more = a.getTransformation(drawingTime, t, 1f);
if (more) {
final RectF region = parent.mInvalidateRegion;
a.getInvalidateRegion(0, 0, mRight - mLeft, mBottom - mTop, region,
invalidationTransform);
// The child need to draw an animation, potentially offscreen, so
// make sure we do not cancel invalidate requests
// //這里設(shè)置了一個表示該View含有動畫的標記位，在后面會使用這個標記位
parent.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
final int left = mLeft + (int) region.left;
final int top = mTop + (int) region.top;
//這里請求重繪，根據(jù)動畫改變的子View的可繪制區(qū)域的位置。
//我們知道View Animation 是沒有改變原本View的屬性，包括寬高位置。
parent.invalidate(left, top, left + (int) (region.width() + .5f),
top + (int) (region.height() + .5f));
}
//balabala
}
public void invalidate(int l, int t, int r, int b) {
final int scrollX = mScrollX;
final int scrollY = mScrollY;
invalidateInternal(l - scrollX, t - scrollY, r - scrollX, b - scrollY, true, false);
}
public RenderNode updateDisplayListIfDirty() {
//....
if(condition){
....
draw(canvas);
}
//....
}
這里調(diào)用invalidateInternal()函數(shù)就是請求重繪，具體怎么重繪，我們在下面會講。
上面的過程是View繪制的大體流程，下面看看設(shè)置動畫的情況。我們設(shè)置View動畫的入口函數(shù)一般都是startAnimation()，下面我們從這里入手。
//View.java
public void startAnimation(Animation animation) {
animation.setStartTime(Animation.START_ON_FIRST_FRAME);
setAnimation(animation);
invalidateParentCaches();
invalidate(true);
}
invalidate(true)函數(shù)的主要作用是請求View樹進行重繪,但是具體是怎么繪制的呢，我們接著往下看。
//View.java
void invalidate(boolean invalidateCache) {
//這里的mLeft，mRight都是相當于父View來講的。所以這里的參數(shù)就是當前View所在的區(qū)域。
invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true);
}
void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
boolean fullInvalidate) {
//不需要繪制的情況（View不可見&&沒有動畫等）
if (skipInvalidate()) {
return;
}
//...
if(condition/*滿足需要繪制的條件*/){
final AttachInfo ai = mAttachInfo;
final ViewParent p = mParent;
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
damage.set(l, t, r, b);
p.invalidateChild(this, damage);
}
}
//....
}
OK,在上面小節(jié)提到的函數(shù)在這里出現(xiàn)了，我們看看究竟是怎么一回事。上面函數(shù)大多是設(shè)置標記位和判斷標記位，具體什么意思還不是很清楚，我們重點看下那一小段,這里的mAttachInfo是在View第一次attach到Window時，ViewRoot傳給自己的子View的。這個AttachInfo之后，會順著布局體系一直傳遞到最底層的View，下面看看ViewParent到底做了什么？
//ViewGroup.java
public final void invalidateChild(View child, final Rect dirty) {
ViewParent parent = this;
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
final boolean drawAnimation = (child.mPrivateFlags & PFLAG_DRAW_ANIMATION)
== PFLAG_DRAW_ANIMATION; //applyLegacyAnimation（）中有設(shè)置這個標記位
final int[] location = attachInfo.mInvalidateChildLocation;
location[CHILD_LEFT_INDEX] = child.mLeft;
location[CHILD_TOP_INDEX] = child.mTop; //localtion存放的子view的右上角的坐標
...
do {
View view = null;
if (parent instanceof View) {
view = (View) parent;
}
//這里意味著如果子View有動畫，那么父View也要設(shè)置上動畫標記位，一直到頂層ViewRootImpl
if (drawAnimation) {
if (view != null) {
view.mPrivateFlags |= PFLAG_DRAW_ANIMATION;
} else if (parent instanceof ViewRootImpl) {
((ViewRootImpl) parent).mIsAnimating = true;
}
}
// If the parent is dirty opaque or not dirty, mark it dirty with the opaque
// flag coming from the child that initiated the invalidate
if (view != null) {
if ((view.mViewFlags & FADING_EDGE_MASK) != 0 &&
view.getSolidColor() == 0) {
opaqueFlag = PFLAG_DIRTY;
}
if ((view.mPrivateFlags & PFLAG_DIRTY_MASK) != PFLAG_DIRTY) {
view.mPrivateFlags = (view.mPrivateFlags & ~PFLAG_DIRTY_MASK) | opaqueFlag;
}
}
parent = parent.invalidateChildInParent(location, dirty);
if (view != null) {
// Account for transform on current parent
Matrix m = view.getMatrix();
if (!m.isIdentity()) {
RectF boundingRect = attachInfo.mTmpTransformRect;
boundingRect.set(dirty);
m.mapRect(boundingRect);
dirty.set((int) (boundingRect.left - 0.5f),
(int) (boundingRect.top - 0.5f),
(int) (boundingRect.right + 0.5f),
(int) (boundingRect.bottom + 0.5f));
}
}
} while (parent != null);
}
}
這里調(diào)用了函數(shù)invalidateChildInParent()，需要注意的是這里這個函數(shù)的實現(xiàn)有兩個，一個是ViewGroup中，而另一個是ViewRootImpl。
//ViewGroup.java
//總體來講，這里就是修改一些參數(shù)，使其滿足當前的ViewGroup,比如坐標等。
public ViewParent invalidateChildInParent(final int[] location, final Rect dirty) {
if ((mPrivateFlags & PFLAG_DRAWN) == PFLAG_DRAWN ||
(mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID) {
if ((mGroupFlags & (FLAG_OPTIMIZE_INVALIDATE | FLAG_ANIMATION_DONE)) !=
FLAG_OPTIMIZE_INVALIDATE) {
dirty.offset(location[CHILD_LEFT_INDEX] - mScrollX,
location[CHILD_TOP_INDEX] - mScrollY);
if ((mGroupFlags & FLAG_CLIP_CHILDREN) == 0) {
dirty.union(0, 0, mRight - mLeft, mBottom - mTop);
}
final int left = mLeft;
final int top = mTop;
if ((mGroupFlags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN) {
if (!dirty.intersect(0, 0, mRight - left, mBottom - top)) {
dirty.setEmpty();
}
}
mPrivateFlags &= ~PFLAG_DRAWING_CACHE_VALID;
location[CHILD_LEFT_INDEX] = left;
location[CHILD_TOP_INDEX] = top;
if (mLayerType != LAYER_TYPE_NONE) {
mPrivateFlags |= PFLAG_INVALIDATED;
}
return mParent;
} else {
mPrivateFlags &= ~PFLAG_DRAWN & ~PFLAG_DRAWING_CACHE_VALID;
location[CHILD_LEFT_INDEX] = mLeft;
location[CHILD_TOP_INDEX] = mTop;
if ((mGroupFlags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN) {
dirty.set(0, 0, mRight - mLeft, mBottom - mTop);
} else {
// in case the dirty rect extends outside the bounds of this container
dirty.union(0, 0, mRight - mLeft, mBottom - mTop);
}
if (mLayerType != LAYER_TYPE_NONE) {
mPrivateFlags |= PFLAG_INVALIDATED;
}
return mParent;
}
}
return null;
}
而在ViewRootImpl中就是請求整個View Tree進行重繪，具體的代碼如下。
@Override
public void invalidateChild(View child, Rect dirty) {
invalidateChildInParent(null, dirty);
}
@Override
public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
checkThread(); //UI線程才可以操作UI
...
invalidateRectOnScreen(dirty);
return null;
}
private void invalidateRectOnScreen(Rect dirty) {
...
if (!mWillDrawSoon && (intersected || mIsAnimating)) {
scheduleTraversals();
}
}
根據(jù)上篇對Window/WindowManager和WindowManagerSystem的理解,我們通過分析ViewRootImpl的繪制的時候分析過，函數(shù)scheduleTraversals()的邏輯其實是執(zhí)行一個Runnable，而這個Runnable其實就是去執(zhí)行函數(shù)doTraversal(),而函數(shù)doTraversal()會調(diào)用performTraversals(),到這里我們發(fā)現(xiàn)它開始重繪了。總體來說就是動畫的執(zhí)行會導致整個View Tree重繪，但是Android內(nèi)部有一些優(yōu)化，比如一張圖片做移動，我們不需要真正的去重新繪制，Android內(nèi)部提供緩存機制，不會顯示的再調(diào)用onDraw(canvas)函數(shù)。
到這里，動畫的執(zhí)行邏輯大體清楚了。
QA
ViewGroup及其子類onDraw(canvas)沒有執(zhí)行
ViewGroup沒有背景時默認是不會執(zhí)行onDraw(canvas)方法的，具體的原因我們在下面分析。
public ViewGroup(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
initViewGroup();
initFromAttributes(context, attrs, defStyleAttr, defStyleRes);
}
private void initViewGroup() {
// ViewGroup doesn't draw by default
if (!debugDraw()) {
setFlags(WILL_NOT_DRAW, DRAW_MASK); //設(shè)置相關(guān)的標記位
}
....
}
//#View.java
//可以看見在View里也包含這個設(shè)置
//willNotDraw = true ,不繪畫
public void setWillNotDraw(boolean willNotDraw) {
setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
}
//View.java
//WILL_NOT_DRAW = 0x00000080;
//DRAW_MASK = 0x00000080;
void setFlags(int flags, int mask) {
....
int old = mViewFlags;
mViewFlags = (mViewFlags & ~mask) | (flags & mask);//（flags & mask）= 0x00000080
int changed = mViewFlags ^ old;
....
if ((changed & DRAW_MASK) != 0) {
if ((mViewFlags & WILL_NOT_DRAW) != 0) {
if (mBackground != null
|| (mForegroundInfo != null && mForegroundInfo.mDrawable != null)) {
//需要繪制時的標記位，通過這里我們知道，有背景時設(shè)置是無效的，這里很容易驗證
mPrivateFlags &= ~PFLAG_SKIP_DRAW;
} else {
mPrivateFlags |= PFLAG_SKIP_DRAW; //不要繪制，添加標記位
}
} else {
mPrivateFlags &= ~PFLAG_SKIP_DRAW;
}
requestLayout();
invalidate(true);
}
...
}
//View.java
//這個函數(shù)上面有分析，在boolean draw(Canvas canvas, ViewGroup parent, long drawingTime)
//中調(diào)用，使用這個函數(shù)來繪制View本身部分，通過這里，我們可以看到如果添加了PFLAG_SKIP_DRAW標記
//那么該View的繪制會被跳過，從而直接分發(fā)到子View
public RenderNode updateDisplayListIfDirty() {
...
//當包含標記位時直接分發(fā)
if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
dispatchDraw(canvas);
...
} else {
draw(canvas); //文章開頭的6步繪制過程
}
...
}
