android Xfermode PorterDuffXfermode 实现遮罩层

package com.example.testsurfaceview;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.PaintDrawable;
import android.util.AttributeSet;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;

@SuppressLint("NewApi")
public class CustomSurfaceView extends SurfaceView implements Callback {

    public CustomSurfaceView(Context context, AttributeSet attrs,
            int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init();
    }

    public CustomSurfaceView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public CustomSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public CustomSurfaceView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.getHolder().addCallback(this);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        Canvas canvas = getHolder().lockCanvas();
        canvas.drawColor(Color.WHITE);

        int w = canvas.getWidth();
        int h = canvas.getHeight();

        Bitmap bitmap = this.getIcon(this.getContext());
        
        Bitmap mat = BitmapFactory.decodeResource(this.getResources(), R.drawable.default_icon_mask);

        bitmap = this.composeMat(this.getContext(), bitmap, mat);
        
        int left = (w - bitmap.getWidth()) / 2;
        int top = (h - bitmap.getHeight()) / 2;

        canvas.drawBitmap(bitmap, left, top, new Paint());

        getHolder().unlockCanvasAndPost(canvas);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
        // TODO Auto-generated method stub

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // TODO Auto-generated method stub

    }

    private Bitmap getIcon(Context mContext) {
        int wh = (int) mContext.getResources().getDimension(R.dimen.icon_wh);
        int width = wh;
        int height = wh;
        Drawable icon = mContext.getResources().getDrawable(
                R.drawable.ic_launcher);

        if (icon instanceof PaintDrawable) {
            PaintDrawable painter = (PaintDrawable) icon;
            painter.setIntrinsicWidth(width);
            painter.setIntrinsicHeight(height);
        } else if (icon instanceof BitmapDrawable) {
            // Ensure the bitmap has a density.
            BitmapDrawable bitmapDrawable = (BitmapDrawable) icon;
            Bitmap bitmap = bitmapDrawable.getBitmap();
            if (bitmap.getDensity() == Bitmap.DENSITY_NONE) {
                bitmapDrawable.setTargetDensity(mContext.getResources()
                        .getDisplayMetrics());
            }
        }
        int sourceWidth = icon.getIntrinsicWidth();
        int sourceHeight = icon.getIntrinsicHeight();

        if (sourceWidth > 0 && sourceHeight > 0) {
            // There are intrinsic sizes.
            if (wh < sourceWidth || wh < sourceHeight) {
                // It‘s too big, scale it down.
                final float ratio = (float) sourceWidth / sourceHeight;
                if (sourceWidth > sourceHeight) {
                    height = (int) (width / ratio);
                } else if (sourceHeight > sourceWidth) {
                    width = (int) (height * ratio);
                }
            } else if (sourceWidth < width && sourceHeight < height) {
                // Don‘t scale up the icon
                width = sourceWidth;
                height = sourceHeight;
            }
        }
        int textureWidth = wh;
        int textureHeight = wh;
        final Bitmap bitmap = Bitmap.createBitmap(textureWidth, textureHeight,
                Bitmap.Config.ARGB_8888);
        Canvas sCanvas = new Canvas();
        sCanvas.setBitmap(bitmap);
        sCanvas.drawColor(Color.GRAY);

        final int left = (textureWidth - width) / 2;
        final int top = (textureHeight - height) / 2;
        icon.setBounds(left, top, left + width, top + height);

        Rect sOldBounds = new Rect();
        sOldBounds.set(icon.getBounds());
        icon.setBounds(left, top, left + width, top + height);
        icon.draw(sCanvas);
        icon.setBounds(sOldBounds);
        sCanvas.setBitmap(null);

        return bitmap;
    }

    private static final Paint sThemePaint2 = new Paint();
    private static final android.graphics.Xfermode Xfermode_DST_IN = new PorterDuffXfermode(
            Mode.DST_IN);
    private static final android.graphics.Xfermode Xfermode_SRC_IN = new PorterDuffXfermode(
            Mode.SRC_IN);

    private Bitmap composeMat(Context context, Bitmap src, Bitmap mat) {
        int sIconWidth = mat.getWidth();
        int sIconHeight = mat.getHeight();
        final Bitmap base = Bitmap.createBitmap(sIconWidth, sIconHeight,
                Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(base);
        sThemePaint2.setXfermode(null);
//        canvas.drawRect(new Rect(0, 0, sIconWidth, sIconHeight), sThemePaint2);
//        sThemePaint2.setXfermode(Xfermode_SRC_IN);
        canvas.drawBitmap(mat, (sIconWidth-mat.getWidth())/2, (sIconHeight-mat.getHeight())/2, sThemePaint2);
        sThemePaint2.setXfermode(Xfermode_SRC_IN);        
        canvas.drawBitmap(src, ((sIconWidth-src.getWidth())/2), (sIconHeight-src.getHeight())/2, sThemePaint2);
        sThemePaint2.setXfermode(null);

        return base;
    }

}