cómo serializar un objeto de android.graphics.Path

Intento almacenar objetos de Android.graphics.Path en la memoria interna del dispositivo. ¿Alguien sabe cómo serializar un objeto android.graphics.Path? Y también, ¿hay alguna otra forma de almacenar un objeto Path? Gracias.

La forma en que lo hice es identificar los métodos que necesitaba de la clase Path original y luego simplemente anular esos métodos de la siguiente manera:

public class CustomPath extends Path implements Serializable { private static final long serialVersionUID = -5974912367682897467L; private ArrayList actions = new ArrayList(); private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{ in.defaultReadObject(); drawThisPath(); } @Override public void moveTo(float x, float y) { actions.add(new ActionMove(x, y)); super.moveTo(x, y); } @Override public void lineTo(float x, float y){ actions.add(new ActionLine(x, y)); super.lineTo(x, y); } private void drawThisPath(){ for(PathAction p : actions){ if(p.getType().equals(PathActionType.MOVE_TO)){ super.moveTo(p.getX(), p.getY()); } else if(p.getType().equals(PathActionType.LINE_TO)){ super.lineTo(p.getX(), p.getY()); } } } public interface PathAction { public enum PathActionType {LINE_TO,MOVE_TO}; public PathActionType getType(); public float getX(); public float getY(); } public class ActionMove implements PathAction, Serializable{ private static final long serialVersionUID = -7198142191254133295L; private float x,y; public ActionMove(float x, float y){ this.x = x; this.y = y; } @Override public PathActionType getType() { return PathActionType.MOVE_TO; } @Override public float getX() { return x; } @Override public float getY() { return y; } } public class ActionLine implements PathAction, Serializable{ private static final long serialVersionUID = 8307137961494172589L; private float x,y; public ActionLine(float x, float y){ this.x = x; this.y = y; } @Override public PathActionType getType() { return PathActionType.LINE_TO; } @Override public float getX() { return x; } @Override public float getY() { return y; } } } 

En mi ejemplo, necesito “moveTo” y “lineTo”, por lo que en este caso simplemente guardo la información del dibujo en una lista. Esta lista contiene la información de dibujo (lo que llamo “acción”) que necesita Path para restaurar el dibujo tal como era antes de que el objeto se serializara. Luego, cuando deserializo mis objetos de tipo CustomPath, me aseguro de dejar que el protocolo de serialización predeterminado llame a “drawThisPath”, por lo que se vuelve a dibujar la ruta.

Me las arreglé para resolver esto. Mi aplicación se basa en FingerPaintDemo, por lo que utiliza solo moveTo y quadTo, pero creo que puede aplicar este enfoque a cualquier función de Path.

Primero, amplíe la ruta de la siguiente manera:

 import android.graphics.Path; import java.util.ArrayList; import java.io.Serializable; public class SerializablePath extends Path implements Serializable { private ArrayList pathPoints; public SerializablePath() { super(); pathPoints = new ArrayList(); } public SerializablePath(SerializablePath p) { super(p); pathPoints = p.pathPoints; } public void addPathPoints(float[] points) { this.pathPoints.add(points); } public void loadPathPointsAsQuadTo() { float[] initPoints = pathPoints.remove(0); this.moveTo(initPoints[0], initPoints[1]); for (float[] pointSet : pathPoints) { this.quadTo(pointSet[0], pointSet[1], pointSet[2], pointSet[3]); } } } 

No creo que tenga que pegar el código de implementación, pero si quieres verlo, házmelo saber. Básicamente justo cuando llamas algo como myPath.quadTo (x1, y1, x2, y2), también llamas a myPath.addPathPoints (nuevo float [] {x1, y1, x2, y2}).

Serialice el objeto en el disco de forma normal, y cuando lo vuelva a leer, solo asegúrese de llamar a myPath.loadPathPointsAsQuadTo ().

No hay nada tan especial para Path Class. El uso puede serializar cualquier clase que implemente la interfaz Serializable.

La interfaz serializable es una interfaz Marker. es decir, no tiene ningún método para implementar. Simplemente significa que el objeto puede ser deflactado a archivos / Memroies y luego puede ser inflado para ser un objeto en vivo de nuevo

Lo que hace, simplemente crea una clase que amplíe su clase android.graphics.Path e implemente la interfaz Serializable. Luego use esta clase en lugar de su android.graphics.Path. Entonces podrá aplicar la serialización sobre él.

Y revise el siguiente enlace para obtener información detallada

http://java.sun.com/developer/technicalArticles/Programming/serialization/

Espero que esto ayude 🙂