Android硬件位圖填坑之獲取硬件畫布

時間 2019-11-17

原文原文鏈接

前言

Hardware Bitmap（硬件位圖）是Android8.0加入的新功能，經過設置Bitmap的config爲Bitmap.Config.HARDWARE，建立所謂的Hardware Bitmap，它不一樣與其餘Config的Bitmap，Hardware Bitmap對應的像素數據是存儲在顯存中，並對圖片僅在屏幕上繪製的場景作了優化；html

硬件位圖的介紹參考Glide文檔java

何如使用Hardware Bitmap

建立Hardware Bitmap

衆所周知，Bitmap的建立通常是調用BitmapFactory這個工廠類來實現，因爲Hardware Bitmap須要配置Bitmap.Config.HARDWARE屬性，一個基本的獲取用Hardware Bitmap的寫法以下：node

val options = BitmapFactory.Options()
 options.inPreferredConfig = Bitmap.Config.HARDWARE
 val bitmap = BitmapFactory.decodeResource(resources, R.drawable.dog, options)
複製代碼

主要是須要設置BitmapFactory.Options的inPreferredConfig爲Bitmap.Config.HARDWARE；android

針對HARDWARE狀況BitmapFactory的提示git

若是設置了inPreferredConfig = Bitmap.Config.HARDWARE，千萬不要設置options.inMutable = true，這樣會引發報錯，由於Hardware Bitmap是不可變的，也不能被利用；另外inBitmap屬性也沒有必要設置，由於硬件位圖不須要當前進程的緩存複用，若是設置inBitmap可能會替換掉以前設置的inPreferredConfig屬性;github

使用Hardware Bitmap

經過上一步的建立，咱們得到Bitmap對象，首先咱們能夠經過bitmap.getConfig()獲取到當前Bitmap是否是Hardware，其次，大多數狀況下，咱們是把Bitmap設置給ImageView控件；canvas

imageView.setImageBitmap(bitmap)
複製代碼

一行代碼搞定imageView沒錯，這行代碼通常狀況下是沒有問題的，那麼問題在哪裏？緩存

首先，硬件位圖只支持GPU的繪製，言外之意是這個ImageView必須在開啓硬件加速的Activity中，並且當前這個ImageView不能設置軟件層 (software layer type)；bash

開啓硬件加速的代碼

//application級別開啓硬件加速
<application android:hardwareAccelerated="true"> 
    <activity ..../>
</>

//activity級別開啓硬件加速
<activity android:hardwareAccelerated="true"/>
複製代碼

在View 上使用software layer type

ImageView imageView = …
imageView.setImageBitmap(hardwareBitmap);
imageView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
複製代碼

若是咱們知足硬件加速和不設置software layer type這兩個條件，在正真使用中還有坑，其中最大的也最頻繁發生的就是經過Canvas來改變Bitmap的形狀或者其餘的轉換；app

拿圓形圖片作例子

假設咱們須要顯示圓形圖片，通常解決方案有兩種：經過自定義控件處理和經過Glide等工具類直接剪裁Bitmap；當Bitmap剪裁遇到HARDWARE就是問題的開始；

經過自定義控件好比CircleImageView的方案，onDraw()方法以下：

@Override
protected void onDraw(Canvas canvas) {
    if (mDisableCircularTransformation) {
        super.onDraw(canvas);
        return;
    }
    if (mBitmap == null) {
        return;
    }

    if (mCircleBackgroundColor != Color.TRANSPARENT) {
        canvas.drawCircle(mDrawableRect.centerX(), mDrawableRect.centerY(), mDrawableRadius, mCircleBackgroundPaint);
    }
    canvas.drawCircle(mDrawableRect.centerX(), mDrawableRect.centerY(), mDrawableRadius, mBitmapPaint);
    if (mBorderWidth > 0) {
        canvas.drawCircle(mBorderRect.centerX(), mBorderRect.centerY(), mBorderRadius, mBorderPaint);
    }
    }
複製代碼

這是CircleImageView從新onDraw()方法，經過自定義控件實現剪切圓角，在設置硬件位圖Bitmap時，通常都沒有問題；

經過相似Glide等直接處理Bitmap的方式剪裁圓形圖片，基本代碼以下:

Canvas canvas = new Canvas(resultBitmap);
  // Draw a circle
  canvas.drawCircle(radius, radius, radius, CIRCLE_CROP_SHAPE_PAINT);
  // Draw the bitmap in the circle
  canvas.drawBitmap(inBitmap, null, destRect, CIRCLE_CROP_BITMAP_PAINT);
  clear(canvas);
複製代碼

經過相似工具類的形式直接對Bitmap進行修改，執行到canvas.drawBitmap就會報異常，異常信息是java.lang.IllegalStateException: Software rendering doesn't support hardware bitmaps;

如何避免報異常

我大體想了這麼兩個方案：

方案一：全部關於剪切Bitmap的操做都改爲自定義控件，在自定義控件的onDraw中實現；
方案二：尋找一種方案，解決掉本身建立的Canvas不報異常，這樣就能繼續用工具類來處理Bitmap；

方案一技術實現比較簡單，把項目中所用用處處理Bitmap的邏輯都換成自定義控件，可是可能涉及到不少處代碼的修改，是一個功夫活；

方案二實施起來有點障礙，由於除了經過new Canvas(Bitmap)獲取畫布，還能經過什麼方式能拿到Canvas，對了還有SurfaceView也是能夠拿到Canvas，可是SurfaceView不支持硬件加速，因此直接就Pass了，想實現方案二我認爲得弄清自定義控件onDraw()方法中Canvas從何而來;

分析Canvas流程

View.onDraw()中的Canvas從何而來

咱們知道，View的繪製流程是從ViewRootImpl.performTraversals()這個方法開始

performTraversals()

boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;

    if (!cancelDraw && !newSurface) {
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
            mPendingTransitions.get(i).startChangingAnimations();
            }
            mPendingTransitions.clear();
        }
        //調動performDraw()
        performDraw();
    } else {
        if (isViewVisible) {
            // Try again
            scheduleTraversals();
        } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).endChangingAnimations();
            }
            mPendingTransitions.clear();
        }
    }
複製代碼

performTraversals()方法調用performDraw()，而後performDraw()方法中又調用draw(fullRedrawNeeded)，大部門繪製的邏輯都是在draw(fullRedrawNeeded)方法中;

draw(fullRedrawNeeded)

if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
        if (mAttachInfo.mThreadedRenderer != null && mAttachInfo.mThreadedRenderer.isEnabled()) {
        //省略代碼
        mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
        } else {
    if (mAttachInfo.mThreadedRenderer != null &&
            !mAttachInfo.mThreadedRenderer.isEnabled() &&
            mAttachInfo.mThreadedRenderer.isRequested()) {
        //省略代碼    
        //drawSoftware
        if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
            return;
            }           
        }
    }
複製代碼

從draw(fullRedrawNeeded)方法能夠看到，若是支持硬件加速，調用mAttachInfo.mThreadedRenderer.draw()方法，不然調用drawSoftware()方法，繪製的基本流程從這裏分叉；

drawSoftware如何得到Canvas

drawSoftware()

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
        boolean scalingRequired, Rect dirty) {
    // Draw with software renderer.
    final Canvas canvas;
    try {
        final int left = dirty.left;
        final int top = dirty.top;
        final int right = dirty.right;
        final int bottom = dirty.bottom;
        canvas = mSurface.lockCanvas(dirty);
        Surface.lockCanvas()
        //noinspection ConstantConditions
        if (left != dirty.left || top != dirty.top || right != dirty.right
                || bottom != dirty.bottom) {
            attachInfo.mIgnoreDirtyState = true;
        }

        canvas.setDensity(mDensity);
    } catch (Surface.OutOfResourcesException e) {
        handleOutOfResourcesException(e);
        return false;
    } catch (IllegalArgumentException e) {
        mLayoutRequested = true; 
        return false;
    }
    //省略代碼
}
複製代碼

從drawSoftware()方法能夠知道，軟件繪製的流程是從Surface.lockCanvas()得到Canvas對象；

View體系硬件加速Canvas建立過程

ThreadedRenderer.draw()

void draw(View view, AttachInfo attachInfo, DrawCallbacks callbacks) {
    attachInfo.mIgnoreDirtyState = true;
    final Choreographer choreographer = attachInfo.mViewRootImpl.mChoreographer;
    choreographer.mFrameInfo.markDrawStart();
    //調用updateRootDisplayList更新DisplayList
    updateRootDisplayList(view, callbacks);
}
複製代碼

ThreadedRenderer.updateRootDisplayList()

private void updateRootDisplayList(View view, DrawCallbacks callbacks) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Record View#draw()");
    updateViewTreeDisplayList(view);
    if (mRootNodeNeedsUpdate || !mRootNode.isValid()) {
        //經過RootNode.start建立DisplayListCanvas
        DisplayListCanvas canvas = mRootNode.start(mSurfaceWidth, mSurfaceHeight);
    try {
        final int saveCount = canvas.save();
        canvas.translate(mInsetLeft, mInsetTop);
        callbacks.onPreDraw(canvas);
        canvas.insertReorderBarrier();
        canvas.drawRenderNode(view.updateDisplayListIfDirty());
        canvas.insertInorderBarrier();
        callbacks.onPostDraw(canvas);
        canvas.restoreToCount(saveCount);
        mRootNodeNeedsUpdate = false;
    } finally {
        //最終調用end方法
        mRootNode.end(canvas);
    }
    }
    Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
複製代碼

View.updateDisplayListIfDirty()

public RenderNode updateDisplayListIfDirty() {
    final RenderNode renderNode = mRenderNode;
    //省略代碼
        int layerType = getLayerType();
        //建立DisplayListCanvas
        final DisplayListCanvas canvas = renderNode.start(width, height);
        canvas.setHighContrastText(mAttachInfo.mHighContrastText);
        try {
            //判斷layerType
            if (layerType == LAYER_TYPE_SOFTWARE) {
                buildDrawingCache(true);
                Bitmap cache = getDrawingCache(true);
                if (cache != null) {
                    canvas.drawBitmap(cache, 0, 0, mLayerPaint);
                }
            } else {
                computeScroll();
                canvas.translate(-mScrollX, -mScrollY);
                mPrivateFlags |= PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID;
                mPrivateFlags &= ~PFLAG_DIRTY_MASK;
                // Fast path for layouts with no backgrounds
                if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
                    dispatchDraw(canvas);//dispatchDraw
                    drawAutofilledHighlight(canvas);
                    if (mOverlay != null && !mOverlay.isEmpty()) {
                        mOverlay.getOverlayView().draw(canvas);
                    }
                    if (debugDraw()) {
                        debugDrawFocus(canvas);
                    }
                } else {
                    //調用draw()方法
                    draw(canvas);
                }
            }
        } finally {
            renderNode.end(canvas);
            setDisplayListProperties(renderNode);
        }
    } else {
        mPrivateFlags |= PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID;
        mPrivateFlags &= ~PFLAG_DIRTY_MASK;
    }
    return renderNode;
}
複製代碼

從上面基本流程能夠看出，硬件加速下Canvas的建立是調用RenderNode.create()方法，每一個View都有本身的RenderNode，RenderNode的建立是在View的構造方法中；

View構造方法

public View(Context context) {
    mContext = context;
    mResources = context != null ? context.getResources() : null;
    mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED | FOCUSABLE_AUTO;
    //省略
    mRenderNode = RenderNode.create(getClass().getName(), this);
    //省略
}
複製代碼

RenderNode經過調用靜態方法create獲得RenderNode對象，咱們繼續看RenderNode.create()方法

RenderNode.create()

/**
 * @param name The name of the RenderNode, used for debugging purpose. May be null.
 * @return A new RenderNode.
 */
public static RenderNode create(String name, @Nullable View owningView) {
    return new RenderNode(name, owningView);
}
複製代碼

create()方法有兩個參數，第一個name，第二個是owningView，並且是能夠爲空的，從註釋上來看，name只是爲了調試用，並且owningView能夠爲空，咱們能夠用反射去建立一個簡單的RenderNode;

嘗試建立一個Canvas

回顧一下，寫出一個簡單的建立一個硬件加速Canvas的代碼：

第一行，建立RenderNode
RenderNode node = RenderNode.create("helloworld", null);
第二行，建立DisplayListCanvas
final DisplayListCanvas canvas = node.start(bitmapWidth, bitmapHeight);
第三行，執行canvas的操做
canvas.xxx();
第四行，執行node.end()方法
node.end(canvas);
複製代碼

一個簡單的DisplayListCanvas建立流程在腦海中浮現出來，可是還有個問題，咱們執行完canvas的繪製操做以後，生成的產物Bitmap從哪裏獲得，咱們回顧和ViewRootImpl打交道的硬件加速繪製相關的類是ThreadedRenderer，咱們剛纔看了這個類的draw()方法和updateRootDisplayList()方法，頗有意思，它還有一個這個靜態的方法createHardwareBitmap(RenderNode node, int width, int height)；

ThreadedRenderer.createHardwareBitmap()

public static Bitmap createHardwareBitmap(RenderNode node, int width, int height) {
    return nCreateHardwareBitmap(node.getNativeDisplayList(), width, height);
}
複製代碼

該方法根據傳入的RenderNode建立一個硬件加速的Bitmap並返回，要求傳入的這個node必須是根root，在這裏，一個完整的獲取替換Canvas的流程應該是這樣；

第一行，建立RenderNode
RenderNode node = RenderNode.create("helloworld", null);
第二行，建立DisplayListCanvas
final DisplayListCanvas canvas = node.start(width, height);
第三行，執行canvas的操做
canvas.xxx();
第四行，執行node.end()方法
node.end(canvas);
第五行，調用createHardwareBitmap生成Bitmap
bitmap = ThreadedRenderer.createHardwareBitmap(node,width,height)
複製代碼

基於上面的僞代碼分析，我寫了一個避免反射調優化版的Hardware Canvas，基本調用以下：

//建立HardwareCanvasManager
val hardwareCanvasManager = HardwareCanvasManager()
try {
    //獲取canvas
    val canvas = hardwareCanvasManager.createCanvas(size, size)
    //畫圓形or其餘繪製
    canvas.drawCircle(radius, radius, radius, CIRCLE_CROP_SHAPE_PAINT);
    //畫原圖，經過畫筆設置SRC_IN屬性
    canvas.drawBitmap(inBitmap, null, destRect, CIRCLE_CROP_BITMAP_PAINT);
    //獲得bitmap
    val buildBitmap = hardwareCanvasManager.buildBitmap()
    //將bitmap設置給ImageView
    iv.setImageBitmap(buildBitmap)
} finally {
    //清理工做
    hardwareCanvasManager.clean()
}
複製代碼

Github傳送門