Il percorso Finger Paint diventa enorme nel tempo e rallenta l'app

Quindi sto scrivendo un'app Finger paint. Ho più colori che l'utente può selezionare. Salvare il percorso e dipingere le informazioni all'interno di un array.

  ArrayList<PaintPath> arrayPaintPath = new ArrayList<PaintPath>();

Il percorso di pittura è

class PaintPath{
    Paint aPaint;
    Path  aPath;
    PaintPath(Paint paint, Path path){
        aPaint = paint;
        aPath   = path;
    }
}

e all'interno di onTouch raccolgo per ogni azione.

@Override
public boolean onTouchEvent(MotionEvent event) {

    float x = event.getX();
    float y = event.getY();

    switch(event.getAction()){
    case MotionEvent.ACTION_DOWN:
        mypath  = new Path();
        mypaint = new Paint();
        mypaint.setAntiAlias(true);
        mypaint.setStyle(Paint.Style.STROKE);
        mypaint.setStrokeWidth(8f);
        mypath.moveTo(x, y);
        break;

    case MotionEvent.ACTION_MOVE:
        mypath.lineTo(x, y);
        break;

    default:
        return true;
    }

    // see which color was selected by user
    setColor(mypaint); 

    // see if eraser was selected
    if(Palette.currentPaletteState == Palette.PaletteState.ERASER){
        mypaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        mypaint.setStrokeWidth(50f); 
    }

    // Here is were the array gets populated and the onDraw method 
    // use this array to draw
    arrayPaintPath.add(new PaintPath(mypaint,mypath));

    // force to call onDraw method
    invalidate();
    return true;  // return true to keep the event to this child only
}

Quindi metodo onDraw

@Override
protected void onDraw(Canvas canvas) {

    for(PaintPath p: arrayPaintPath){

        mycanvas.drawPath(p.aPath, p.aPaint);

        canvas.drawBitmap(bmp, 0, 0,null);

    }
}

Quindi il problema principale è con il forloop. Mentre l'utente dipinge con il passare del tempo, il percorso e la pittura vengono raccolti, così come il percorso della gomma viene raccolto. L'array diventa sempre più grande. Questo riduce significativamente le prestazioni.

So che potrei usare SurfaceView e gestire il lavoro in un altro thread, ma anche quel thread finirà per fare il looping sull'enorme array.

Qualcuno sa quale sarebbe una soluzione elegante a questo?