Android, canvas: come posso cancellare (eliminare il contenuto di) una tela (= bitmap), vivendo in un surfaceView?

Per realizzare un gioco semplice, ho utilizzato un modello che disegna una tela con bitmap come questo:

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

(La tela è definita in "run ()" / SurfaceView risiede in un GameThread.)

La mia prima domanda è: come posso cancellare (o ridisegnare) l' intera tela per un nuovo layout?
Secondo, come posso aggiornare solo una parte dello schermo?

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

Come posso cancellare (o ridisegnare) l'intera tela per un nuovo layout (= provare il gioco)?

Chiama Canvas.drawColor(Color.BLACK)o qualsiasi colore con cui vuoi cancellare il tuo Canvas.

E: come posso aggiornare solo una parte dello schermo?

Non esiste un metodo simile che aggiorni solo una "parte dello schermo" poiché il sistema operativo Android sta ridisegnando ogni pixel durante l'aggiornamento dello schermo. Ma, quando non cancelli i vecchi disegni sul tuo Canvas, i vecchi disegni sono ancora in superficie e questo è probabilmente un modo per "aggiornare solo una parte" dello schermo.

Quindi, se vuoi "aggiornare una parte dello schermo", evita di chiamare il Canvas.drawColor()metodo.

Disegna colori trasparenti con la modalità trasparente di PorterDuff fa il trucco per quello che volevo.

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

Ho trovato questo nei gruppi di Google e questo ha funzionato per me ..

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

Questo rimuove i rettangoli dei disegni ecc. Mantenendo la bitmap impostata.

Ho provato la risposta di @mobistry:

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

Ma non ha funzionato per me.

La soluzione, per me, era:

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

Forse qualcuno ha lo stesso problema.

utilizzare il metodo di ripristino della classe Path

Path.reset();

mBitmap.eraseColor(Color.TRANSPARENT);

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

si prega di incollare sotto il codice nel costruttore della classe estendere la vista di superficie .............

codifica del costruttore

    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 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" />

prova il codice sopra ...

Ecco il codice di un esempio minimo che mostra che devi sempre ridisegnare ogni pixel della tela in ogni fotogramma.

Questa attività disegna una nuova bitmap ogni secondo in SurfaceView, senza prima cancellare lo schermo. Se lo provi, vedrai che la bitmap non viene sempre scritta nello stesso buffer e lo schermo si alternerà tra i due buffer.

L'ho testato sul mio telefono (Nexus S, Android 2.3.3) e sull'emulatore (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();
                }
            }
        }   
    }
}

Per me la chiamata Canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)o qualcosa di simile funzionerebbe solo dopo aver toccato lo schermo. Quindi chiamerei la riga di codice sopra, ma lo schermo si cancellerebbe solo dopo aver toccato lo schermo. Quindi quello che ha funzionato per me è stato chiamare invalidate()seguito da init()cui viene chiamato al momento della creazione per inizializzare 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);

La cancellazione su Canvas in java Android è simile alla cancellazione di HTML Canvas tramite javascript con globalCompositeOperation. La logica era simile.

U sceglierà la logica DST_OUT (Destination Out).

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

Nota: DST_OUT è più utile perché può cancellare il 50% se il colore della vernice ha il 50% alfa. Quindi, per passare completamente al trasparente, l'alfa del colore deve essere 100%. Si consiglia di applicare paint.setColor (Color.WHITE). E assicurati che il formato dell'immagine su tela fosse RGBA_8888.

Dopo la cancellazione, torna al disegno normale con SRC_OVER (Source Over).

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

Aggiornare letteralmente il display di una piccola area dovrà accedere all'hardware grafico e potrebbe non essere supportato.

Il livello più vicino per ottenere le massime prestazioni sta utilizzando il livello multi immagine.

Non dimenticare di chiamare invalidate ();

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

Prova a rimuovere la visualizzazione in onPause () di un'attività e aggiungi onRestart ()

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

Nel momento in cui aggiungi la tua vista, verrà chiamato il metodo onDraw ().

YourCustomView, è una classe che estende la classe View.

Nel mio caso, disegno la mia tela in linearlayout. Per pulire e ridisegnare di nuovo:

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

e poi, chiamo la classe con i nuovi valori:

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

Questa è la 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
    }
}

Con il seguente approccio, puoi cancellare l'intera tela o solo una parte di essa.
Non dimenticare di disabilitare l'accelerazione hardware poiché PorterDuff.Mode.CLEAR non funziona con l'accelerazione hardware e infine chiama setWillNotDraw(false)perché sovrascriviamo il onDrawmetodo.

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

Il tuo primo requisito, come cancellare o ridisegnare l'intera tela - Risposta - usa il metodo canvas.drawColor (color.Black) per cancellare lo schermo con un colore nero o qualsiasi cosa tu specifichi.

Il tuo secondo requisito, come aggiornare parte dello schermo - Rispondi - ad esempio se vuoi mantenere tutte le altre cose invariate sullo schermo ma in una piccola area dello schermo per mostrare un numero intero (diciamo contatore) che aumenta ogni cinque secondi. quindi usa il metodo canvas.drawrect per disegnare quella piccola area specificando sinistra in alto a destra in basso e dipingi. quindi calcola il valore del tuo contatore (usando postdalayed per 5 secondi ecc., come Handler.postDelayed (Runnable_Object, 5000);), convertilo in stringa di testo, calcola le coordinate xey in questo piccolo rettangolo e usa la visualizzazione del testo per visualizzare la modifica controvalore.

Ho dovuto utilizzare un passaggio di disegno separato per cancellare la tela (bloccare, disegnare e sbloccare):

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

Chiama soltanto

canvas.drawColor (Color.TRANSPARENT)