绘制绘画后，更改画笔，然后根据该画笔效果在Android画布中更改整个绘画颜色

Question

我为画布创建了不同的画笔效果。 当我更换画笔时，先前绘制的油漆将更改为该画笔效果。 那我该怎么做？ 如果有任何指导，请给我。

下面是我的DrawingView类。

public class DrawingView extends View
{
    private final Paint  mPaintSrcIn   = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.FILTER_BITMAP_FLAG);
    private final Paint  mPaintDstIn   = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.FILTER_BITMAP_FLAG);
    public Paint  mPaintColor   = new Paint(Paint.ANTI_ALIAS_FLAG);
    public Paint  mPaintColor1   = new Paint(Paint.ANTI_ALIAS_FLAG);
//  public final Paint  mPaintColor2   = new Paint(Paint.ANTI_ALIAS_FLAG);
//  public final Paint  mPaintColor3   = new Paint(Paint.ANTI_ALIAS_FLAG);
    private final Paint  mPaintEraser  = new Paint(Paint.ANTI_ALIAS_FLAG);

    private final Matrix mMatrix = new Matrix();
    private final Canvas mLayerCanvas = new Canvas();

    private Bitmap mInnerShape;
    private Bitmap mOuterShape;
    private Bitmap mLayerBitmap;

    private Color mInnerColor,mOuterColor;
    PlayActivity playActivity = new PlayActivity();
    private int mFlag;
    private int paintAlpha = 255;
    private int paintColor = 0xFFFF0000;

    private ArrayList<DrawOp> mDrawOps = new ArrayList<DrawOp>();
    private ArrayList<DrawOp> mDrawOps1 = new ArrayList<DrawOp>();
    private DrawOp mCurrentOp = new DrawOp();
    private DrawOp mPreviousOp = new DrawOp();

    private ArrayList<DrawOp> mUndoneOps = new ArrayList<DrawOp>();

    public DrawingView(Context context)
    {
        this(context, null, 0);
    }

    public DrawingView(Context context, AttributeSet attrs)
    {
        this(context, attrs, 0);
    }

    public DrawingView(Context context, AttributeSet attrs, int defStyle)
    {
        super(context, attrs, defStyle);

        mPaintSrcIn.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        mPaintDstIn.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));

        mPaintColor.setStyle(Paint.Style.STROKE);
        mPaintColor.setStrokeJoin(Paint.Join.ROUND);
        mPaintColor.setStrokeCap(Paint.Cap.ROUND);

        mPaintEraser.set(mPaintColor);
        mPaintEraser.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        mPaintEraser.setMaskFilter(new BlurMaskFilter(getResources()
            .getDisplayMetrics().density * 4, BlurMaskFilter.Blur.NORMAL));
    }

    public void setShape(int inner, int outer)
    {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inPreferredConfig = Bitmap.Config.ALPHA_8;
        setShape(BitmapFactory.decodeResource(getResources(), inner, options),
            BitmapFactory.decodeResource(getResources(), outer, options));
    }

    public void setShape(Bitmap inner, Bitmap outer)
    {
        mInnerShape = inner;
        mOuterShape = outer;
        requestLayout();
        invalidate();
    }

    public void setDrawingColor(int color)
    {
        mCurrentOp.reset();
        mCurrentOp.type = DrawOp.Type.PAINT;
        mCurrentOp.color = color;

        mPreviousOp.reset();
        mPreviousOp.type = DrawOp.Type.PAINT;
        mPreviousOp.color = color;
    }

    public void setDrawingStroke(int stroke)
    {
        mCurrentOp.reset();
        mCurrentOp.type = DrawOp.Type.PAINT;
        mCurrentOp.stroke = stroke;
    }

    public void enableEraser()
    {
        mCurrentOp.reset();
        mCurrentOp.type = DrawOp.Type.ERASE;
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh)
    {
        super.onSizeChanged(w, h, oldw, oldh);
        mLayerBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        mLayerCanvas.setBitmap(mLayerBitmap);

        if(mOuterShape != null){
            int dx = (w - mOuterShape.getWidth()) / 2;
            int dy = (h - mOuterShape.getHeight()) / 2;
            mMatrix.setTranslate(dx, dy);
        }
    }

    @Override
    protected void onDraw(Canvas canvas)
    {
        super.onDraw(canvas);

        if(isInEditMode()){
            return;
        }

        // NOTE: Without extra bitmap or layer.. but HW Acceleration does not support setMaskFilter which means
        // eraser has strong edges whilst drawing.
        // @see http://developer.android.com/guide/topics/graphics/hardware-accel.html#unsupported 

        System.out.println("Flag before if "+mFlag);

        if(mFlag==0){
            System.out.println("Flag = 0 "+mFlag);
            // Clear software canvas
//          mPaintColor1 = mPaintColor;
            mPaintColor.setStyle(Paint.Style.STROKE);
            mPaintColor.setStrokeJoin(Paint.Join.ROUND);
            mPaintColor.setStrokeCap(Paint.Cap.ROUND);
            mPaintColor.setMaskFilter(null);


            mLayerCanvas.drawColor(0, PorterDuff.Mode.CLEAR);

            // Draw picture from ops
            for (DrawOp op : mDrawOps) {
                drawOp(mLayerCanvas, op);
            }
            drawOp(mLayerCanvas, mCurrentOp);

            System.out.println("Drawing Flag : " + mFlag);


            // Mask the drawing to the inner surface area of the shape
            mLayerCanvas.drawBitmap(mInnerShape, mMatrix, mPaintDstIn);

            // Draw orignal shape to view
            canvas.drawBitmap(mOuterShape, mMatrix, null);

            // Draw masked image to view
            canvas.drawBitmap(mLayerBitmap, 0, 0, null);

        }else if(mFlag==1){


            mPaintColor.setStyle(Paint.Style.STROKE);
            mPaintColor.setStrokeJoin(Paint.Join.ROUND);
            mPaintColor.setStrokeCap(Paint.Cap.ROUND);
            mPaintColor.setMaskFilter(null);


            // Clear software canvas
            mLayerCanvas.drawColor(0, PorterDuff.Mode.CLEAR);

            // Draw picture from ops
            for(DrawOp op : mDrawOps){
                drawOp(mLayerCanvas, op);
            }
            drawOp(mLayerCanvas, mCurrentOp);

            // Mask the drawing to the inner surface area of the shape
            mLayerCanvas.drawBitmap(mInnerShape, mMatrix, mPaintDstIn);

            // Draw orignal shape to view
            canvas.drawBitmap(mOuterShape, mMatrix, null);

            // Draw masked image to view
            canvas.drawBitmap(mLayerBitmap, 0, 0, null);
            canvas.save();

        }
        else if(mFlag==2){
                System.out.println("Flag = 2 "+mFlag);

//              mPaintColor1 = mPaintColor;
             /* Blur Effect for creating more effect then change following properties 
                BlurMaskFilter.Blur.INNER,BlurMaskFilter.Blur.NORMAL,BlurMaskFilter.Blur.OUTER
                BlurMaskFilter.Blur.SOLID*/
//              Code Here
                BlurMaskFilter mBlur = new BlurMaskFilter(15, BlurMaskFilter.Blur.NORMAL);
                mPaintColor.setMaskFilter(mBlur);


            // Clear software canvas
            mLayerCanvas.drawColor(0, PorterDuff.Mode.CLEAR);



            // Draw picture from ops
            for (DrawOp op : mDrawOps) {
                drawOp(mLayerCanvas, op);
            }
            drawOp(mLayerCanvas, mCurrentOp);

            // Mask the drawing to the inner surface area of the shape
            mLayerCanvas.drawBitmap(mInnerShape, mMatrix, mPaintDstIn);  /*mPaintDstIn*/ 

            // Draw orignal shape to view
            canvas.drawBitmap(mOuterShape, mMatrix, null);

            // Draw masked image to view
            canvas.drawBitmap(mLayerBitmap, 0, 0, null);
            canvas.save();
        }
        else if(mFlag==3){

            mPaintColor.setStyle(Paint.Style.STROKE);
            mPaintColor.setStrokeJoin(Paint.Join.ROUND);
            mPaintColor.setStrokeCap(Paint.Cap.ROUND);
            mPaintColor.setMaskFilter(null);

            mPaintColor.setMaskFilter(new EmbossMaskFilter(new float[] { 1, 1, 1 },0.4f, 10, 8.2f));

            // Clear software canvas
            mLayerCanvas.drawColor(0, PorterDuff.Mode.CLEAR);

            // Draw picture from ops
            for (DrawOp op : mDrawOps) {
                drawOp(mLayerCanvas, op);
            }
            drawOp(mLayerCanvas, mCurrentOp);

            // Mask the drawing to the inner surface area of the shape
            mLayerCanvas.drawBitmap(mInnerShape, mMatrix, mPaintDstIn);

            // Draw orignal shape to view
            canvas.drawBitmap(mOuterShape, mMatrix, null);

            // Draw masked image to view
            canvas.drawBitmap(mLayerBitmap, 0, 0, null);
            canvas.save();
        }
    }

    private void drawOp(Canvas canvas, DrawOp op)
    {
        if(op.path.isEmpty()){
            return;
        }
        final Paint paint;
        if(op.type == DrawOp.Type.PAINT){
            paint = mPaintColor;
            paint.setColor(op.color);
            paint.setStrokeWidth(op.stroke);
        }else{
            paint = mPaintEraser;
            paint.setStrokeWidth(op.stroke);
        }
        mLayerCanvas.drawPath(op.path, paint);
    }

    @SuppressLint("ClickableViewAccessibility")
    @Override
    public boolean onTouchEvent(MotionEvent event)
    {
        final float x = event.getX();
        final float y = event.getY();

        switch(event.getAction()){
            case MotionEvent.ACTION_DOWN:
                mUndoneOps.clear();
                mCurrentOp.path.moveTo(x, y);

                break;

            case MotionEvent.ACTION_MOVE:

                for(int i = 0; i < event.getHistorySize(); i++){
                    mCurrentOp.path.lineTo(event.getHistoricalX(i), event.getHistoricalY(i));
                }
                mCurrentOp.path.lineTo(x, y);
                break;

            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mCurrentOp.path.lineTo(x, y);
                mDrawOps.add(new DrawOp(mCurrentOp));
                mCurrentOp.path.reset();
                break;
        }

        invalidate();

        return true;
    }

    private static class DrawOp
    {
        public final Path path = new Path();
        public Type type;
        public int  color;
        public int  stroke;


        public DrawOp()
        {
            //
        }

        public void reset()
        {
            this.path.reset();
        }

        public DrawOp(DrawOp op)
        {
            this.path.set(op.path);
            this.type   = op.type;
            this.color  = op.color;
            this.stroke = op.stroke;
        }

        public static enum Type
        {
            PAINT, ERASE;
        }
    }

    public void setFlag(int flag) {
        System.out.println("Before Set mFlag " + mFlag);
        this.mFlag = flag;
        System.out.println("After Set mFlag " + mFlag);
    }

}

这是我的活动类，用于通过单击按钮来更改画笔效果

public class PlayActivity extends Activity{
    private DrawingView mDrawingView;
    private ViewGroup mBrushPanel;
    private ViewGroup mBrushColors;
    private SeekBar mBrushStroke;

    private ViewGroup brush_panel_pencil;
    private ViewGroup brush_colors_pencil;
    private SeekBar brush_stroke_pencil;
    String imagName ="";

    private static String APP_ID = "788092211287311";
    // Instance of Facebook Class
    private Facebook facebook;
    private AsyncFacebookRunner mAsyncRunner;
    String FILENAME = "AndroidSSO_data";
    private SharedPreferences mPrefs;

    public boolean flag = false;

    String name="";
    File file = null;
    FileOutputStream fOut = null;

    // see:
    // http://stackoverflow.com/questions/25758294/how-to-fill-different-color-on-same-area-of-imageview-color-over-another-color/
    static int[] COLORS = { Color.rgb(255, 51, 255), // DARK PINK
            Color.rgb(255, 230, 102), // LIGHT YELLOW
            Color.rgb(148, 66, 50), // DARK MAROON
            Color.rgb(186, 123, 68), // LIGHT MAROON
            Color.rgb(252, 20, 20), // RED
            Color.rgb(102, 255, 255), // LIGHT BLUE

            Color.rgb(70, 78, 202), // DARK BLUE
            Color.rgb(190, 255, 91), // LIGHT GREEN
            Color.rgb(15, 230, 0), // DARK GREEN
            Color.rgb(123, 0, 230), // JAMBLI
            Color.rgb(255, 187, 50), // ORANGE
            Color.rgb(7, 5, 0), // BLACK

    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        getWindow().setBackgroundDrawable(
                Utils.createCheckerBoard(getResources(), 16));

        setContentView(R.layout.activity_play);

        mDrawingView = (DrawingView) findViewById(R.id.drawing_view);
        // mDrawingView.setShape(R.drawable.img_a_inner, R.drawable.img_a);

        mDrawingView.setShape(R.drawable.inner, R.drawable.outer);
        mDrawingView.setDrawingColor(getResources().getColor(R.color.ab_color));

        mDrawingView.setFlag(0);

        mBrushPanel = (ViewGroup) findViewById(R.id.brush_panel);
        mBrushColors = (ViewGroup) findViewById(R.id.brush_colors);
        mBrushStroke = (SeekBar) findViewById(R.id.brush_stroke);

        mBrushStroke
                .setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                    @Override
                    public void onStopTrackingTouch(SeekBar seekBar) {
                    }

                    @Override
                    public void onProgressChanged(SeekBar seekBar,
                            int progress, boolean fromUser) {
                        mDrawingView.setDrawingStroke(progress);
                    }

                    @Override
                    public void onStartTrackingTouch(SeekBar seekBar) {
                    }
                });
        mBrushStroke.setProgress(30);


        mBrushPanel.getViewTreeObserver().addOnPreDrawListener(
                new ViewTreeObserver.OnPreDrawListener() {
                    @Override
                    public boolean onPreDraw() {
                        mBrushPanel.getViewTreeObserver()
                                .removeOnPreDrawListener(this);
                        mBrushPanel
                                .setTranslationY(isLandscape() ? -mBrushPanel
                                        .getHeight() : mBrushPanel.getHeight());
                        return false;
                    }
                });

        createBrushPanelContent();
    }


    @SuppressWarnings("null")
    private void createBrushPanelContent() {
        TableRow tableRow = null;
        final int rowLimit = isLandscape() ? 16 : 8;
        for (int i = 0; i < COLORS.length; i++) {
            if ((i % rowLimit) == 0) {
                tableRow = new TableRow(this);
                mBrushColors.addView(tableRow, new TableLayout.LayoutParams(
                        WRAP_CONTENT, WRAP_CONTENT));
            }
            tableRow.addView(createToolButton(tableRow,
                    R.drawable.ic_paint_splot, i));

        }
        /*tableRow.addView(createToolButton1(tableRow, R.drawable.ic_paint_splot,
                1));*/
    }

    private void showBrushPanel() {
        mBrushPanel.animate().translationY(0).start();
    }

    private void hideBrushPanel() {
        mBrushPanel
                .animate()
                .translationY(
                        isLandscape() ? -mBrushPanel.getHeight() : mBrushPanel
                                .getHeight()).start();
    }

    private boolean isLandscape() {
        return getResources().getBoolean(R.bool.is_landscape);
    }

    private ImageButton createToolButton(ViewGroup parent, int drawableResId,
            int index) {
        ImageButton button = (ImageButton) getLayoutInflater().inflate(
                R.layout.button_paint_spot, parent, false);
        button.setImageResource(drawableResId);
        button.setOnClickListener(mButtonClick);
        if (index != -1) {
            button.setTag(Integer.valueOf(index));
            button.setColorFilter(COLORS[index]);
        }
        return button;
    }


/*  private Button createToolButton1(ViewGroup parent, int drawableResId,
            int index) {
        Button buttonShare = (Button) getLayoutInflater().inflate(
                R.layout.button, parent, false);
        buttonShare.setOnClickListener(mButtonShare);
        return buttonShare;
    }


    };*/

    private View.OnClickListener mButtonClick = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
//          code for set the shadow color 
//          mDrawingView.mPaintColor.setShadowLayer(10, 10, 5, Color.RED);
            mDrawingView.setDrawingColor(COLORS[((Integer) v.getTag())
                    .intValue()]);
            hideBrushPanel();
        }
    };


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_play, menu);
        return super.onCreateOptionsMenu(menu) | true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {

        case R.id.action_emboss:
            mDrawingView.setFlag(3);
            System.out.println("mClick Emboss");
            mDrawingView.setDrawingStroke(30);
            if (mBrushPanel.getTranslationY() == 0) {
                hideBrushPanel();
            } else {
                showBrushPanel();
            }
            break;

        case R.id.action_watermark:
            mDrawingView.setFlag(2);
            mDrawingView.setDrawingStroke(30);
            BlurMaskFilter mBlur = new BlurMaskFilter(15, BlurMaskFilter.Blur.NORMAL);
            mDrawingView.mPaintColor.setMaskFilter(mBlur);

            if (mBrushPanel.getTranslationY() == 0) {
                hideBrushPanel();
            } else {
                showBrushPanel();
            }
            break;
        case R.id.action_pencil:

            mDrawingView.setFlag(1);
            mDrawingView.setDrawingStroke(4);
            if (mBrushPanel.getTranslationY() == 0) {
                    hideBrushPanel();
                } else {
                    showBrushPanel();
                }
            break;

        case R.id.action_brush:

            mDrawingView.setFlag(0);
            mDrawingView.setDrawingStroke(30);
                if (mBrushPanel.getTranslationY() == 0) {
                    hideBrushPanel();
                } else {
                    showBrushPanel();
                }
            break;

        case R.id.action_eraser:
            mDrawingView.enableEraser();
            break;

        case R.id.action_undo:
            mDrawingView.undoOperation();
            break;

        case R.id.action_redo:
            mDrawingView.redoOperation();
            break;

        case R.id.action_save: {
            mDrawingView
                    .setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
            mDrawingView.setDrawingCacheEnabled(true);
            mDrawingView.buildDrawingCache();
            Bitmap viewCache = mDrawingView.getDrawingCache();
            Bitmap bitmap = viewCache.copy(viewCache.getConfig(), false);
            mDrawingView.setDrawingCacheEnabled(false);
            new SaveTask().execute(bitmap);

            View view = findViewById(R.id.relative);
            view.setDrawingCacheEnabled(true);
            // Bitmap bitmap2 = view.getDrawingCache();
            final Bitmap bitmap2 = bitmap.copy(Bitmap.Config.ARGB_8888,
                    true);
            final BitmapDrawable bitmapDrawable = new BitmapDrawable(
                    bitmap2);

            LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            View layout = inflater.inflate(R.layout.horizon,
                    (ViewGroup) findViewById(R.id.main_relative_output));

            RelativeLayout rl = (RelativeLayout) layout
                    .findViewById(R.id.main_relative_output);

            /*AlertDialog builder = new AlertDialog.Builder(
                    PlayActivity.this).setView(layout).show();*/

            //Convert to byte array
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            bitmap2.compress(Bitmap.CompressFormat.PNG, 100, stream);
            byte[] byteArray = stream.toByteArray();


            Intent i = new Intent(PlayActivity.this, SharingScreen.class);
            i.putExtra("image",byteArray);
            i.putExtra("name", name);
            startActivity(i);
//          rl.setBackgroundDrawable(bitmapDrawable);
        }
            break;

        case R.id.action_cancel:
            mDrawingView.clearDrawing();
//          file.delete();
            /*if(viewCache.isRecycled()){
            viewCache.recycle();
            bitmap.recycle();
            }*/
            break;

         /*case R.id.action_share:
                mDrawingView.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
                mDrawingView.setDrawingCacheEnabled(true);
                   mDrawingView.buildDrawingCache();
                    Bitmap viewCache = mDrawingView.getDrawingCache();
                    Bitmap bitmap = viewCache.copy(viewCache.getConfig(), false);
                    new SaveAndShare().execute(bitmap);


                    break;*/


        default:
            return super.onOptionsItemSelected(item);
        }

        return true;
    }


}