Android, canvas: Como faço para limpar (excluir o conteúdo de) uma tela (= bitmaps), vivendo em um surfaceView?

Para fazer um jogo simples, usei um modelo que desenha uma tela com bitmaps 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); } }

(A tela é definida em "run ()" / o SurfaceView reside em um GameThread.)

Minha primeira pergunta é como faço para limpar (ou redesenhar) a tela inteira para um novo layout?
Em segundo lugar, como posso atualizar apenas uma parte da tela?

// 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);  }   }   }       }

Como eu limpo (ou redesenho) a tela TODA para um novo layout (= experimente no jogo)?

Basta ligar Canvas.drawColor(Color.BLACK)ou qualquer cor com a qual você deseja limpar o seu Canvas.

E: como posso atualizar apenas uma parte da tela?

Não existe um método que apenas atualize uma "parte da tela", já que o sistema operacional Android está redesenhando cada pixel ao atualizar a tela. Mas, quando você não está limpando desenhos antigos em seuCanvas , os desenhos antigos ainda estão na superfície e essa é provavelmente uma maneira de "atualizar apenas uma parte" da tela.

Portanto, se você deseja "atualizar uma parte da tela", apenas evite chamar o Canvas.drawColor()método.

Desenhar cores transparentes com o modo de limpeza PorterDuff resolve o que eu queria.

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

Encontrei isso em grupos do Google e funcionou para mim ..

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

Isso remove retângulos de desenhos etc., enquanto mantém o bitmap definido.

Tentei a resposta de @mobistry:

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

Mas não funcionou para mim.

A solução, para mim, foi:

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

Talvez alguém tenha o mesmo problema.

use o método de redefinição da classe Path

Path.reset();

mBitmap.eraseColor(Color.TRANSPARENT);

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

cole o código abaixo em surfaceview extend class constructor .............

codificação do construtor

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

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

codificação 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" />

tente o código acima ...

Aqui está o código de um exemplo mínimo, mostrando que você sempre tem que redesenhar cada pixel do Canvas em cada quadro.

Esta atividade desenha um novo Bitmap a cada segundo no SurfaceView, sem limpar a tela antes. Se você testá-lo, verá que o bitmap nem sempre é gravado no mesmo buffer e a tela alternará entre os dois buffers.

Testei no meu telefone (Nexus S, Android 2.3.3) e no 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 mim, ligar Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)ou algo semelhante só funcionaria depois de tocar na tela. Então, eu chamaria a linha de código acima, mas a tela só limparia depois que eu toquei na tela. Então, o que funcionou para mim foi chamar invalidate()seguido de init()que é chamado no momento da criação para inicializar a visualização.

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);

Apagar no Canvas em java android é semelhante ao apagar HTML Canvas via javascript com globalCompositeOperation. A lógica era semelhante.

U escolherá a lógica DST_OUT (Destination Out).

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

Nota: DST_OUT é mais útil porque pode apagar 50% se a cor da tinta tiver 50% alfa. Portanto, para clarear completamente para transparente, o alfa da cor deve ser 100%. Aplicar paint.setColor (Color.WHITE) é recomendado. E certifique-se de que o formato da imagem da tela era RGBA_8888.

Depois de apagado, volte ao desenho normal com SRC_OVER (Source Over).

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

Atualizar a exibição de pequena área literalmente precisará acessar o hardware gráfico e talvez não seja compatível.

O mais próximo para o melhor desempenho é usar a camada de várias imagens.

Não se esqueça de chamar invalidate ();

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

Tente remover a visualização em onPause () de uma atividade e adicionar onRestart ()

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

No momento em que você adiciona sua visão, o método onDraw () é chamado.

YourCustomView, é uma classe que estende a classe View.

No meu caso, desenho minha tela em layout linear. Para limpar e redesenhar novamente:

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

e então chamo a classe com os novos valores:

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

Esta é a classe 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
    }
}

Com a abordagem a seguir, você pode limpar toda a tela ou apenas uma parte dela.
Não se esqueça de desabilitar a aceleração de hardware, pois PorterDuff.Mode.CLEAR não funciona com aceleração de hardware e, finalmente, chamar setWillNotDraw(false)porque substituímos o 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); 

Seu primeiro requisito, como limpar ou redesenhar a tela inteira - Resposta - use o método canvas.drawColor (color.Black) para limpar a tela com uma cor preta ou o que você especificar.

Seu segundo requisito, como atualizar parte da tela - Resposta - por exemplo, se você deseja manter todas as outras coisas inalteradas na tela, mas em uma pequena área da tela para mostrar um número inteiro (digamos, contador) que aumenta a cada cinco segundos. em seguida, use o método canvas.drawrect para desenhar essa pequena área especificando a parte superior esquerda inferior direita e pintar. em seguida, calcule o valor do contador (usando postdalayed por 5 segundos etc., como Handler.postDelayed (Runnable_Object, 5000);), converta-o em string de texto, calcule a coordenada xey neste pequeno retângulo e use a visualização de texto para exibir a alteração valor do contador.

Tive que usar um passe de desenho separado para limpar a tela (bloquear, desenhar e 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);
    }
}

Apenas ligue

canvas.drawColor (Color.TRANSPARENT)