Pfthb

Just starting out with Android, canvas, the works. I have existing Java code that can draw shapes on a graphics object. I am trying to use that code in an Android app with Canvas. Basically, I'm trying to avoid refactoring all of my Java code to use Canvas explicitly. So I'm in the process of making my own "Graphics" object. All it should do is call the appropriate Canvas methods to draw the specified shape.

I've read multiple posts here about not being able to use the canvas object outside of the onDraw() method. From what I understand, you can't pass a canvas object to a different class and expect it to work correctly. But I also do not have a complete understanding of how all this works.

The app crashes in the Graphics class in the drawOval method. I've read up a log about all of this, but I haven't found a good answer as to why this specifically doesn't work.
I haven't been able to find a way to get crash logs in a java friendly way (aka a stacktrace). It just throws Fatal signal 11 (SIGSEGV), code 1, fault addr 0x130 in tid 1520.

Thanks! Let me know if more details are needed. Here's my code:

MainActivity

public class MainActivity extends AppCompatActivity 

 MyCanvas canvas;
 @Override
 protected void onCreate(Bundle savedInstanceState) 
 super.onCreate(savedInstanceState);
 canvas = new MyCanvas(this);
 setContentView(canvas);
 

MyCanvas View

public class MyCanvas extends View 
 Graphics graphics;
 List<Shape> shapes;

 public MyCanvas(Context context) 
 super(context);
 graphics = new Graphics();
 shapes = new ArrayList<>();
 

 protected void onDraw(Canvas canvas) 
 super.onDraw(canvas);
 graphics.setCanvas(canvas); //Sets the canvas object in the graphics class
 for (Shape shape : shapes) 
 try //this is in a try/catch block for custom exception handling
 //This just calls the specific shapes render method,
 //in this case, a circle from the makeShape Method
 //The graphics object then calls the specific shape to
 //render on the canvas
 shape.render(graphics, 0, 0); 
 catch (ShapeException e) 
 e.printStackTrace();
 
 
 invalidate();
 

 @Override
 public boolean onTouchEvent(MotionEvent event) 
 switch (event.getAction()) 
 case MotionEvent.ACTION_DOWN:
 int x = (int) event.getX();
 int y = (int) event.getY();
 try //this is in a try/catch block for custom exception handling
 makeShape(x, y);
 catch (ShapeException e) 
 e.printStackTrace();
 
 invalidate();

 case MotionEvent.ACTION_MOVE:
 case MotionEvent.ACTION_UP:
 case MotionEvent.ACTION_CANCEL: 
 break;
 
 
 invalidate();
 return true;
 

 public void makeShape(int x, int y) throws ShapeException
 Point p = new Point(x, y);
 Shape shape = new Circle(p, 50, 50);
 shapes.add(shape);
 

Graphics

public class Graphics 
 private Canvas canvas = null;

 public Graphics() 
 

 public void setCanvas(Canvas canvas) 
 if (this.canvas == null) 
 this.canvas = canvas;
 
 

 public void drawOval(int x, int y, int width, int height) 
 Paint paint1 = new Paint();
 paint.setColor(Color.BLACK);
 canvas.drawCircle(500, 500, 50, paint1); //App crashes here
 

You have a slight misunderstanding about being able to pass a Canvas to different classes. There is absolutely nothing wrong with that; passing a canvas to a class method is effectively the same as passing it to a regular function. Even storing the Canvas reference in a member variable isn't going to hurt anything.

HOWEVER, the above is only true with the understanding that the Canvas cannot be used outside the bounds of the draw()/onDraw() method. That is, any method that uses the Canvas must be called from within onDraw(), or a function called by onDraw(), etc.

This is because the Canvas is initialized (by the framework) immediately before onDraw(), in order to prepare for the current drawing operation. You might wish to think of it as initializing the Canvas with a Bitmap that will serve as the drawing output surface for this particular screen frame (which is not far from the truth). Once onDraw() has returned, the framework assumes your code will no longer be using it, and it can submit the output surface/Bitmap/etc. to the screen compositor for rendering, without fear of further alterations.

And, your approach is a good one, as a technique for adapting existing code to use a novel graphics object.

So, to address the crash: SIGSEGVs should never happen in normal Android development when you're not dealing (directly) with native/JNI routines. However, it occurs to me that you're not updating the Canvas object in the event it changes. This could be causing the crash (in native code, which is why you don't get a Java stack trace). You used an old Canvas after a newer one was given to you. Remove the condition if (this.canvas == null) and you should be fine.