Android, lienzo: ¿Cómo borro (elimino el contenido de) un lienzo (= mapas de bits) que vive en un surfaceView?

Para hacer un juego simple, utilicé una plantilla que dibuja un lienzo con mapas de bits como este:

private void doDraw(Canvas canvas) {
    for (int i=0;i<8;i++)
        for (int j=0;j<9;j++)
            for (int k=0;k<7;k++)   {
    canvas.drawBitmap(mBits[allBits[i][j][k]], i*50 -k*7, j*50 -k*7, null); } }

(El lienzo se define en "run ()" / SurfaceView vive en un GameThread).

Mi primera pregunta es ¿cómo borro (o redibujo) todo el lienzo para un nuevo diseño?
En segundo lugar, ¿cómo puedo actualizar solo una parte de la pantalla?

// This is the routine that calls "doDraw":
public void run() {
    while (mRun) {
        Canvas c = null;
        try {
            c = mSurfaceHolder.lockCanvas(null);
            synchronized (mSurfaceHolder) {
                if (mMode == STATE_RUNNING) 
                    updateGame();
                doDraw(c);          }
        } finally {
            if (c != null) {
                mSurfaceHolder.unlockCanvasAndPost(c);  }   }   }       }

¿Cómo borro (o vuelvo a dibujar) TODO el lienzo para un nuevo diseño (= prueba en el juego)?

Simplemente llame Canvas.drawColor(Color.BLACK), o cualquier color con el que desee aclararlo Canvas.

Y: ¿cómo puedo actualizar solo una parte de la pantalla?

No existe tal método que simplemente actualice una "parte de la pantalla", ya que el sistema operativo Android está redibujando cada píxel al actualizar la pantalla. Pero, cuando no está borrando dibujos antiguos en su Canvas, los dibujos antiguos todavía están en la superficie y esa es probablemente una forma de "actualizar solo una parte" de la pantalla.

Por lo tanto, si desea "actualizar una parte de la pantalla", simplemente evite llamar al Canvas.drawColor()método.

Dibujar color transparente con el modo claro de PorterDuff hace el truco para lo que quería.

Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)

Encontré esto en los grupos de Google y esto funcionó para mí.

Paint clearPaint = new Paint();
clearPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
canvas.drawRect(0, 0, width, height, clearPaint); 

Esto elimina los dibujos, rectángulos, etc. mientras se mantiene el mapa de bits establecido.

utilizar el método de reinicio de la clase Path

Path.reset();

Probé la respuesta de @mobistry:

canvas.drawColor(Color.TRANSPARENT, Mode.CLEAR);

Pero no funcionó para mí.

La solución, para mí, fue:

canvas.drawColor(Color.TRANSPARENT, Mode.MULTIPLY);

Quizás alguien tenga el mismo problema.

mBitmap.eraseColor(Color.TRANSPARENT);

canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);

pegue el código debajo en el constructor de clase de extensión de surfaceview .............

codificación del constructor

    SurfaceHolder holder = getHolder();
    holder.addCallback(this);

    SurfaceView sur = (SurfaceView)findViewById(R.id.surfaceview);
    sur.setZOrderOnTop(true);    // necessary
    holder = sur.getHolder();
    holder.setFormat(PixelFormat.TRANSPARENT);

codificación xml

    <com.welcome.panelview.PanelViewWelcomeScreen
        android:id="@+id/one"
        android:layout_width="600px"
        android:layout_height="312px"
        android:layout_gravity="center"
        android:layout_marginTop="10px"
        android:background="@drawable/welcome" />

prueba el código anterior ...

Aquí está el código de un ejemplo mínimo que muestra que siempre debe volver a dibujar cada píxel del lienzo en cada cuadro.

Esta actividad dibuja un nuevo mapa de bits cada segundo en SurfaceView, sin borrar la pantalla antes. Si lo prueba, verá que el mapa de bits no siempre se escribe en el mismo búfer y la pantalla alternará entre los dos búferes.

Lo probé en mi teléfono (Nexus S, Android 2.3.3) y en el emulador (Android 2.2).

public class TestCanvas extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new TestView(this));
    }
}

class TestView extends SurfaceView implements SurfaceHolder.Callback {

    private TestThread mThread;
    private int mWidth;
    private int mHeight;
    private Bitmap mBitmap;
    private SurfaceHolder mSurfaceHolder;

    public TestView(Context context) {
        super(context);
        mThread = new TestThread();
        mBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.icon);
        mSurfaceHolder = getHolder();
        mSurfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
        mWidth = width;
        mHeight = height;
        mThread.start();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {/* Do nothing */}

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        if (mThread != null && mThread.isAlive())
            mThread.interrupt();
    }

    class TestThread extends Thread {
        @Override
        public void run() {
            while (!isInterrupted()) {
                Canvas c = null;
                try {
                    c = mSurfaceHolder.lockCanvas(null);
                    synchronized (mSurfaceHolder) {
                        c.drawBitmap(mBitmap, (int) (Math.random() * mWidth), (int) (Math.random() * mHeight), null);
                    }
                } finally {
                    if (c != null)
                        mSurfaceHolder.unlockCanvasAndPost(c);
                }

                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    interrupt();
                }
            }
        }   
    }
}

Para mí, llamar Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)o algo similar solo funcionaría después de tocar la pantalla. Entonces, llamaría a la línea de código anterior, pero la pantalla solo se borraría después de tocar la pantalla. Entonces, lo que funcionó para mí fue llamar invalidate()seguido de lo init()que se llama en el momento de la creación para inicializar la vista.

private void init() {
    setFocusable(true);
    setFocusableInTouchMode(true);
    setOnTouchListener(this);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setDither(true);
    mPaint.setColor(Color.BLACK);
    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeWidth(6);

    mCanvas = new Canvas();
    mPaths = new LinkedList<>();

    addNewPath();
}

canvas.drawColor(Color.TRANSPARENT, Mode.MULTIPLY);

Borrar en Canvas en java android es similar al borrar HTML Canvas a través de javascript con globalCompositeOperation. La lógica era similar.

U elegirá la lógica DST_OUT (salida de destino).

paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));

Nota: DST_OUT es más útil porque puede borrar un 50% si el color de la pintura tiene un 50% de alfa. Entonces, para aclarar completamente a transparente, el alfa de color debe ser 100%. Se recomienda aplicar paint.setColor (Color.WHITE). Y asegúrese de que el formato de la imagen del lienzo sea RGBA_8888.

Después de borrar, vuelva al dibujo normal con SRC_OVER (Source Over).

paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));

Actualizar la pantalla de área pequeña literalmente necesitará acceder al hardware gráfico, y tal vez no sea compatible.

Lo más cercano para un mayor rendimiento es el uso de capas de imágenes múltiples.

No olvide llamar a invalidate ();

canvas.drawColor(backgroundColor);
invalidate();
path.reset();

Intente eliminar la vista en onPause () de una actividad y agregue onRestart ()

LayoutYouAddedYourView.addView (YourCustomView); LayoutYouAddedYourView.removeView (YourCustomView);

En el momento en que agregue su vista, se llamará al método onDraw ().

YourCustomView, es una clase que amplía la clase View.

En mi caso, dibujo mi lienzo en un diseño lineal. Para limpiar y volver a dibujar:

    LinearLayout linearLayout = findViewById(R.id.myCanvas);
    linearLayout.removeAllViews();

y luego, llamo a la clase con los nuevos valores:

    Lienzo fondo = new Lienzo(this,items);
    linearLayout.addView(fondo);

Esta es la clase Lienzo:

class Lienzo extends View {
    Paint paint;
    RectF contenedor;
    Path path;
    ArrayList<Items>elementos;

    public Lienzo(Context context,ArrayList<Items> elementos) {
        super(context);
        this.elementos=elementos;
        init();
    }

    private void init() {
        path=new Path();
        paint = new Paint();
        contenedor = new RectF();
        paint.setStyle(Paint.Style.FILL);
    }


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

        contenedor.left = oneValue;
        contenedor.top = anotherValue;
        contenedor.right = anotherValue;
        contenedor.bottom = anotherValue;

        float angulo = -90; //starts drawing at 12 o'clock
        //total= sum of all element values
        for (int i=0;i<elementos.size();i++){
            if (elementos.get(i).angulo!=0 && elementos.get(i).visible){
                paint.setColor(elementos.get(i).backColor);
                canvas.drawArc(contenedor,angulo,(float)(elementos.get(i).value*360)/total,true,paint);

                angulo+=(float)(elementos.get(i).value*360)/total;
            }
        } //for example
    }
}

Con el siguiente enfoque, puede borrar todo el lienzo o solo una parte.
No olvide deshabilitar la aceleración de hardware, ya que PorterDuff.Mode.CLEAR no funciona con la aceleración de hardware y, finalmente, llama setWillNotDraw(false)porque anulamos el onDrawmétodo.

//view's constructor
setWillNotDraw(false);
setLayerType(LAYER_TYPE_SOFTWARE, null);

//view's onDraw
Paint TransparentPaint = new Paint();
TransparentPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
canvas.drawRect(0, 0, width, height, TransparentPaint); 

Su primer requisito, cómo borrar o volver a dibujar todo el lienzo - Respuesta - use el método canvas.drawColor (color.Black) para limpiar la pantalla con un color negro o lo que especifique.

Su segundo requisito, cómo actualizar parte de la pantalla - Respuesta - por ejemplo, si desea mantener todas las demás cosas sin cambios en la pantalla pero en un área pequeña de la pantalla para mostrar un número entero (digamos contador) que aumenta después de cada cinco segundos. luego use el método canvas.drawrect para dibujar esa pequeña área especificando la parte superior derecha inferior izquierda y pintar. luego calcule el valor de su contador (usando postdalayed durante 5 segundos, etc., como Handler.postDelayed (Runnable_Object, 5000);), conviértalo en una cadena de texto, calcule las coordenadas xey en este pequeño rect y use la vista de texto para mostrar el cambio valor del contador.

Tuve que usar un pase de dibujo separado para limpiar el lienzo (bloquear, dibujar y desbloquear):

Canvas canvas = null;
try {
    canvas = holder.lockCanvas();
    if (canvas == null) {
        // exit drawing thread
        break;
    }
    canvas.drawColor(colorToClearFromCanvas, PorterDuff.Mode.CLEAR);
} finally {
    if (canvas != null) {
        holder.unlockCanvasAndPost(canvas);
    }
}

Solo llama

canvas.drawColor (Color.TRANSPARENT)