[ CONSULTA ] ¿Como desarrollar sistema de particulas en Android que se acumulen?

[mwest0101]

Hola a todos. Estoy desarrollando un wallpaper animado donde quiero simular nieve que cae y se acumula. Estoy trabajando con canvas.
la idea era dibujar los puntos y para simular el movimiento dibujar los puntos mas abajo y borrar los dibujados en el frame anterior con puntos negros. esto para que al momento de que estos lleguen abajo no borrarlos y que se vaya dibujando de esta forma abajo la nieve acumulada. Intente hacer esto pero al querer borrar los puntos antes dibujados me queda formado líneas de puntos y no logro simular el movimiento. Agradecería si alguien me puede dar una idea de como solucionar mi problema.

Aclaro que la idea de repintar cada punto con negro es para no tener que repintar en cada frame los puntos acumulados abajo, ya que esto demandaría mucho proceso y no lo soportaría ningún terminal.

he buscado ejemplos que me puedan dar lo solución, pero en todos los ejemplos que eh visto todos los puntos están en constante movimiento.


pd:
Actualmente lo he resuelto provisoriamente repintando todo(como no quería hacerlo) pero al completar la segunda línea de puntos acumulada (como era de esperar) el programa empieza a dar saltos porque el procesador no alcanza.

package de.vogella.android.wallpaper;

import java.util.ArrayList;
import java.util.List;

import android.content.SharedPreferences;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.service.wallpaper.WallpaperService;
import android.view.MotionEvent;
import android.view.SurfaceHolder;

public class MyWallpaperService extends WallpaperService {

    @Override
    public Engine onCreateEngine() {
        return new MyWallpaperEngine();
    }

    private class MyWallpaperEngine extends Engine {
        private final Handler handler = new Handler();
        private final Runnable drawRunner = new Runnable() {
            @Override
            public void run() {
                draw();
            }

        };
        private List<MyPoint> circles;
        private List<Integer> base;
        private List<MyPoint> monton;
        private Paint paint = new Paint();
        private int width;
        private int height;
        private int counterBase;
        
        private boolean visible = true;
        private int maxNumber;
        private boolean writeOrClean;
        private boolean touchEnabled;
        int inc=0;
    
        public MyWallpaperEngine() {
    

            SharedPreferences prefs = PreferenceManager
                    .getDefaultSharedPreferences(MyWallpaperService.this);
            maxNumber = Integer
                    .valueOf(prefs.getString("numberOfCircles", "200"));
            touchEnabled = prefs.getBoolean("touch", false);
            circles = new ArrayList<MyPoint>();
            monton = new ArrayList<MyPoint>();
            base = new ArrayList<Integer>();
            paint.setAntiAlias(true);

            paint.setStyle(Paint.Style.STROKE);
            paint.setStrokeJoin(Paint.Join.ROUND);
            paint.setStrokeWidth(2f);

            
        }

        @Override
        public void onVisibilityChanged(boolean visible) {
            this.visible = visible;
            if (visible) {
                handler.post(drawRunner);
            } else {
                handler.removeCallbacks(drawRunner);
            }
        }

        @Override
        public void onSurfaceDestroyed(SurfaceHolder holder) {
            super.onSurfaceDestroyed(holder);
            this.visible = false;
            handler.removeCallbacks(drawRunner);
        }

        @Override
        public void onSurfaceChanged(SurfaceHolder holder, int format,
                int width, int height) {
            this.width = width;
            this.height = height;
            super.onSurfaceChanged(holder, format, width, height);
        }

        @Override
        public void onTouchEvent(MotionEvent event) {
            if (touchEnabled) {

                float x = event.getX();
                float y = event.getY();
                SurfaceHolder holder = getSurfaceHolder();
                Canvas canvas = null;
                try {
                    canvas = holder.lockCanvas();
                    if (canvas != null) {

                        circles.add(new MyPoint(String.valueOf(circles.size()+1),x,y));
                        drawCircles(canvas, circles);

                    }
                } finally {
                    if (canvas != null)
                        holder.unlockCanvasAndPost(canvas);
                }
                super.onTouchEvent(event);
            }
        }
    
        private void draw() {
            SurfaceHolder holder = getSurfaceHolder();
            Canvas canvas = null;
            try {
                canvas = holder.lockCanvas();
                if (canvas != null) {
                    while (counterBase<width){
                        base.add(height-100);
                        counterBase++;
                    }
                    
                    if (circles.size() < 200) {

                    int x = (int) ((width-20) * Math.random())+10;

                    int y = 10;
                    circles.add(new MyPoint(String.valueOf(circles.size() + 1),
                            x, y));
                    }
                    drawCircles(canvas, circles);
                }
            } finally {
                if (canvas != null)
                    holder.unlockCanvasAndPost(canvas);
            }
            handler.removeCallbacks(drawRunner);
            if (visible) {
                handler.postDelayed(drawRunner, 10);
            }
        }

        // Surface view requires that all elements are drawn completely
        private void drawCircles(Canvas canvas, List<MyPoint> circles) {
            canvas.drawColor(Color.BLACK);            
            int numero=0;
            inc++;
            for (MyPoint point : circles) {
            
                        paint.setColor(Color.WHITE);
                    
                
                    //
                    //canvas.drawCircle(point.x, point.y, 4.0f, paint);
                    
                    canvas.drawPoint((int)point.x, (int)point.y, paint);
                    point.y=point.y+10;
                        
                    if ((int)point.y>=base.get((int)point.x)){
                        numero=base.get((int)point.x);
                        base.set((int)point.x, numero-1);

                        point.y=0;
                    }

                    
                
            }
        }
    }

}