Android ändern, Leinwand, hintergrund-Farbe, ohne dass irgendwelche Zeichnungen von ihm

Den bereits gegebenen Antworten zu deiner Frage sind alle in die richtige Richtung weisen: Sie müssen trennen Sie Ihre hintergrund-Farbe-block und der Vordergrund Zeichnung in separate Schichten, dann mischen Sie Sie vor dem speichern das ganze in einer .png-Datei. Dies ist, wie Adobe Photoshop workflow ausgelegt ist, als auch... Es macht Sinn, wenn wir darüber nachdenken: nehmen Sie zum Beispiel eine software wie MsPaint: weil Sie nicht verwenden, Schichten, es hat zu verlassen Sie sich auf Sachen wie Füll-algorithmen zu erreichen (wenn auch in unvollständiger Weise) etwas aus der Ferne ähnlich wie eine hintergrund ändern...

Eine Möglichkeit so etwas umzusetzen wäre zu instanziieren 2 Canvas-Objekte unterstützt durch 2 verschiedene bitmaps. Die erste Leinwand-Bitmap-pair-Mädchen sein würde, die Sie für Ihre Zeichnung im Vordergrund, und die zweite Leinwand-Bitmap-pair-Mädchen sein würde, die Sie für Ihr zusammengeführt-Schichten zeichnen (D. H. Vorder-Zeichnung + hintergrund-Farbe-block). Dann die 2. Bitmap wird gespeichert .png-Datei, wenn Sie es brauchen, um gerettet zu werden. Auf diese Weise, unsere erste Leinwand-Bitmap-pair speichert Ihre Vorder-info, die nicht zerstört werden können, wenn eine hintergrund-Farbe ändern, muss auch gemacht werden. Jedesmal, wenn eine operation gemacht ist, werden die Ebenen zusammengefasst werden können, in der 2. Canvas-Bitmap-pair-Mädchen, so dass es immer eine Bitmap mit dem richtigen Inhalt, der gespeichert werden kann, nach Lust und Laune.

Hier ist eine benutzerdefinierte Ansicht, die ich so gemacht wie klar diese Methode bis. Es implementiert eine einfache Ansicht, um zu malen eine Blaue Linie auf dem Touchscreen-Bildschirm mit einem finger, mit einer hintergrund-Farbe ändern in Abhängigkeit von der X-Y-position, sagte, den finger so zu zeigen, eine hintergrund-Farbe ändern, ohne unnötigen code inhärenten Komplexität einer vollständigen Umsetzung mit einem Farbrad/Menüs/unter anderem:

package com.epichorns.basicpaint;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Paint.Style;
import android.view.View;

public class PaintView extends View{

    Bitmap mMergedLayersBitmap=null; //Note: this bitmap here contains the whole of the drawing (background+foreground) to be saved.
    Canvas mMergedLayersCanvas=null;

    Bitmap mBitmap = null; //bitmap onto which we draw our stuff
    Canvas mCanvas = null; //Main canvas. Will be linked to a .bmp file
    int mBackgroundColor = 0xFF000000; //default background color
    Paint mDefaultPaint = new Paint();

    Paint mDrawPaint = new Paint(); //used for painting example foreground stuff... We draw line segments.
    Point mDrawCoor = new Point(); //used to store last location on our PaintView that was finger-touched

    //Constructor: we instantiate 2 Canvas-Bitmap pairs
    public PaintView(Context context, int width, int height) {
        super(context);
        mMergedLayersBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); 
        mMergedLayersCanvas = new Canvas(mMergedLayersBitmap);

        mBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        mCanvas = new Canvas(mBitmap);
    }

    //Change background color
    public void changeColor(int newColor){
        mBackgroundColor = newColor;
        invalidate(); //refresh view: this will indirectly invoke onDraw soon afterwards
    }

    //Called by user of PaintView in order to start a painting "stroke" (finger touching touch-screen): stores the 
    //location of the finger when it first touched the screen
    public void startDraw(int x, int y, int radius, int color){
        mDrawPaint.setColor(color);
        mDrawPaint.setStyle(Style.STROKE);
        mDrawPaint.setStrokeWidth(radius);
        mDrawCoor.x = x;
        mDrawCoor.y = y;        
    }

    //Called by user of PaintView when finger touching touch-screen is moving (must be called after a startDraw, 
    //as the latter initializes a couple of necessary things)
    public void continueDraw(int x, int y){
        mCanvas.drawLine(mDrawCoor.x, mDrawCoor.y, x, y, mDrawPaint);
        mDrawCoor.x = x;
        mDrawCoor.y = y;
        invalidate(); //refresh view: this will indirectly invoke onDraw soon afterwards
    }

    //Merge the foreground Canvas-Bitmap with a solid background color, then stores this in the 2nd Canvas-Bitmap pair.
    private void mergeLayers(){
        mMergedLayersCanvas.drawColor(mBackgroundColor);
        mMergedLayersCanvas.drawBitmap(mBitmap, 0, 0, mDefaultPaint);
    }

    @Override
    public void onDraw(Canvas canvas){
        mergeLayers();
        canvas.drawBitmap(mMergedLayersBitmap, 0, 0, mDefaultPaint);
    }

}

Um zu testen, diese Ansicht hier ist ein test-Aktivität verwendet, die PaintView Klasse. Diese beiden Dateien werden autark in einem Android-Projekt, so dass Sie können es testen, auf Ihre eigentliche Gerät ohne Hektik:

package com.epichorns.basicpaint;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.View;
import android.widget.LinearLayout;


import com.epichorns.basicpaint.PaintView;
public class BasicPaintActivity extends Activity {
    PaintView mPaintView=null;
    LinearLayout mL = null;
    boolean mIsDrawing=false;
    int mBackgroundColor = 0xFF000000;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Display display = getWindowManager().getDefaultDisplay();       
        final float dispWidth = (float)display.getWidth();
        final float dispHeight = (float)display.getHeight();

        mPaintView = new PaintView(this, display.getWidth(), display.getHeight());    
        mPaintView.changeColor(mBackgroundColor);
        mPaintView.setOnTouchListener(new View.OnTouchListener(){

            public boolean onTouch(View v, MotionEvent event) {

            if(event.getAction()==MotionEvent.ACTION_DOWN){
                    mPaintView.startDraw((int)event.getX(), (int)event.getY(), 6, 0x806060FF);              
                    mIsDrawing=true;
                    return true;
                }
                else if(event.getAction()==MotionEvent.ACTION_UP){
                    mIsDrawing=false;
                    return true;
                }
                else if(event.getAction()==MotionEvent.ACTION_MOVE){
                    if(mIsDrawing){

                        //To demonstrate background change, change background color depending on X-Y position
                        int r = (int)(255f*event.getX()/dispWidth);
                        int g = (int)(255f*event.getY()/dispHeight);
                        mBackgroundColor = Color.argb(0xFF, r,g, 0x00);
                        Log.d("DEBUG1", "Color channels: (r, g) = ("+String.valueOf(r)+", "+String.valueOf(g)+")");
                        mPaintView.changeColor(mBackgroundColor);

                        //now, draw stuff where finger was dragging...
                        mPaintView.continueDraw((int)event.getX(), (int)event.getY());
                        return true;
                    }
                    else{
                        return false;
                    }

                }

                return false;
            }

        });

        setContentView(mPaintView);
    }




}

Aussehen, wenn Sie ändern möchten, in Leinwand -, dann müssen Sie invalidate aufrufen um diese änderungen zu übernehmen auf Ihrem Bildschirm.Und wenn du invalidate aufrufen dann Ihre onDraw() Methode aufrufen.

Wenn Sie möchten, ändern Sie einfach die Hintergrundfarbe der Leinwand aus dem Farbauswahl-speichern Sie die Farbe mit dem Wert in variable und rufen invalidate nur nach dem speichern der variable.Jetzt ist Ihre onDraw() anrufen.Nun ändern Sie den hintergrund der Leinwand durch den Aufruf setBackgroundColor(color variable) im onDraw() - und ziehen alles, was Sie wollen

Solange Ihr hintergrund und werden in einer anderen Farbe, die Sie tun können:

for (x...)
  for (y...)
    if (bitmap.getPixel(x,y) == oldBackgroundColor)
      bitmap.setPixel(x,y,newBackgroundColor)

Oder Sie können zeichnen Sie Ihre Inhalte auf eine offscreen-bitmap und zeichne den hintergrund und dann die offscreen auf die eigentliche bitmap. Auf diese Weise können Sie ändern Sie die Hintergrundfarbe, die verwendet wird, wenn die nächsten zwei-Schritt-Zeichnung geschehen wird.

Vielleicht ist es eine alte Frage, aber ich möchte dazu beitragen mit dieser Lösung, Im Fall, dass Sie unter der bitmap aus einer Quelle, und dann tut ein drawable mit Leinwand, vielleicht kann fit u:

@Override
public Bitmap transform(final Bitmap source) {
    //Background for transparent images
    Bitmap backg = Bitmap.createBitmap(source.getWidth(), source.getHeight(), Bitmap.Config.ARGB_8888);
    backg.eraseColor(Color.WHITE); //Any color you want...
    Paint back = new Paint();
    BitmapShader backshader = new BitmapShader(backg,
    BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
    back.setShader(backshader);
    back.setAntiAlias(true);

    //Image for the draw
    final Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(new BitmapShader(source, Shader.TileMode.CLAMP,
            Shader.TileMode.CLAMP));
    Bitmap output = Bitmap.createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
    Canvas canvas = new Canvas(output);

    //IMPORTANT THING
    canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
            - margin, source.getHeight() - margin), radius, radius, back); //Draw the background first...
    canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
            - margin, source.getHeight() - margin), radius, radius, paint); //And then Draw the image, so it draws on top of the background

    if (source != output) {
        source.recycle();
    }

    //This is for if i want to put a border in the drawable, its optional
    Paint paint1 = new Paint();      
    paint1.setColor(Color.parseColor("#CC6C7B8B"));
    paint1.setStyle(Style.STROKE);
    paint1.setAntiAlias(true);
    paint1.setStrokeWidth(2);
    canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
            - margin, source.getHeight() - margin), radius, radius, paint1);

    //and then, return the final drawable...
    return output;
}

Hoffe, es hilft...