Android development: drawing text on a Canvas

I have an Android project bubbling away. More details soon 🙂

I’m using a SurfaceView and needed to draw some text on it. The rest of the app is mostly drawing on the SurfaceView Canvas directly, but I need some text too.

I’ve dabbled with some Android development before, and I have to admit getting the layouts to do what you want them too almost seems to suck up the majority of my development time 🙁 This time round I got sidetracked trying to create a layout that was using a mix of TextView elements and adding my SurfaceView programmatically. This didn’t go too well, didn’t work at all, so I found a few posts like this, and worked out you need to draw directly on the canvas. Something like this does the job:

Paint textPaint = new Paint();
this.canvas.drawText("Hello world!", 20,50, textPaint);

This code is in the middle of a game display loop, but for completeness, to be able to draw to the Canvas first you need:

SurfaceHolder surfaceHolder = this.getHolder();
if (surfaceHolder.getSurface().isValid()) {
    this.canvas = surfaceHolder.lockCanvas();

And then to release the Canvas after you’ve finished drawing:



Ok, next up, what about custom TTF fonts? Drop the TTF font you want to use in your assets/fonts folder, and then load it up with:

Typeface typeFace = Typeface.createFromAsset(this.context.getAssets(), 

To use this font with the text snippet above, just call setTypeface() and pass it in:


Ok, how about specifying a font size that’s proportional to the resolution of the user’s screen? This is an interesting question. To avoid using fixed pixel size fonts and then having them not scale appropriately for different devices with different screen resolutions, Android uses a concept called ‘scale independent pixels’, or SP. This is described in this post here. In short, defines an SP value in /res/values/dimens.xml/dimens.xml like:

<dimen name="scoreFontSize">20sp</dimen>

And then reference and set it like this:

int fontSize = getResources().getDimensionPixelSize(R.dimen.scoreFontSize);

Done! (I’ll share more on what I’m working on in a few days 🙂

Can you develop code to effectively solve a problem without understanding the problem first? (writing code to solve Sudoku puzzles)

You shouldn’t have to think too hard to answer this question. In order of most likely answer first, least likely last (I hope), your answer could be one of:

a) No. How can you solve a problem if you don’t understand what it is that you’re trying to solve?

b) Possibly, if your approach to solving a vague or poorly defined problem is to ask clarifying/fact finding questions to investigate and gain an understanding of the problem so you can get to a position where you’re able to solve the problem.

c) Yes. (Really?)

There’s no correct answer to this question although I hope you initially answered (a), but (b) is a valid possibility if you consider the effort to understand a problem is an essential part of solving a problem (which of course it is).

I decided I would have a go at writing a Java app to solve Sudoku puzzles. I’m familiar with the rules of Sudoku and have solved a few puzzles by hand. I’m not an expert by any means, but I know enough about this type of puzzle to realize there’s probably at least a few well understood algorithms for effectively solving them, but as I started out I wasn’t familiar with any particular approach.

So here’s my experiment: I decided I would deliberately avoid doing any background reading on known algorithms or reading any articles or discussions on approaches for how to solve, and would attempt to blindly develop my own approach to solve a puzzle to see how successful (or otherwise) I would be. I know the rules to the puzzle, I understand what the end result must be, so how hard can it be, right?

For those unfamiliar with Sudoku, here’s the 3 rules:

  • each 3×3 square must contain each digit 1 through 9 with no repeated values
  • each column must also contain each digit 1 through 9 with no repeated values
  • and the same rule for each row, 1 through 9, with no repeated values

Here’s my starting puzzle that I used to write my code against:

      | 8 1   | 6 7   
    7 | 4 9   | 2   8 
  6   |   5   | 1   4 
- - - + - - - + - - -
1     |     3 | 9     
4     |   8   |     7 
    6 | 9     |     3 
- - - + - - - + - - -
9   2 |   3   |   6   
6   1 |   7 4 | 3     
  3 4 |   6 9 |       

(Puzzle generated by WebSoduku)

My initial approach for my algorithm was to follow the steps I would go through by hand if I were solve a puzzle on paper. This already set me off at a disadvantage because I don’t think I’m particularly skilled or experienced at solving Sudoku, so I wasted some hours trying to capture these steps in code. Going down this path I realized if you take this approach, you mentally ask several questions as you look for possible values for empty squares, but it’s not not the answer to any one of questions that gets you a correct answer, it’s the combination of answers to multiple questions (because there’s 3 constraints, above, that you need to follow). So following this approach, I wrote code to iterate through the complete grid applying my limited set of questions to find potential values for each empty cell. The result was after a couple of iterations I had inserted values into all empty cells as sets of potential values, but my approach was not complete enough to be able to solve the example puzzle I was using for testing.

This is where I reached my point of realization. Clearly I did not understand enough about the problem to be able to write a program to solve it.

After some debugging and tweaking to my approach, I did reach a point where I could solve my test puzzle in 7 passes through the grid, but when testing the same approach with another easy puzzle, my approach failed to reach a solution. So my approach only partially works when I have a starting point with enough values, or a certain distribution through the grid, but fails to solve all puzzles.

At this point I could have continued blindly in the same direction, but I decided I had already proved to myself my point that you can’t solve a problem if you don’t understand what it is that you’re trying to solve. It was time to read up on the the established algorithms to solving, so I could understand what it was that I was missing.

There are a number of established algorithms for solving Sudoku, and I won’t describe or cover them all there, but there’s a good summary on this wikipedia page. The approaches range from brute force (sequentially testing each value 1 through 9 in each cell, with backtracking to prior cells if chosen values fail to find a solution, to variations such as Donald Knuth’s Dancing Links algorithm.

My conclusion to my original question though is clear: had I recognized the problem as an example of an exact cover problem, I would have known that there are established algorithms for solving this type of problem.

You can’t solve a problem if you don’t understand what it is that you’re trying to solve.

If you’re interested in taking a look at my partial solution you can find it here on my Github.

Flashing Cyanogenmod 13 to a Samsung Galaxy S3

I’ve been running Cyanogenmod 12.1 on my Samsung Galaxy S3 for a year or so now, and have updated to various nightly builds when they’re available. Cyanogenmod 13 became available a while back too, so I decided I’d bump up from Lollipop up to Marshmallow.

Lollipop on this one ran pretty smooth, but it looks like it’s struggling with Marshmallow, maybe it hasn’t got the oomph.

I usually find the point I start messing with custom roms is the point where I’m looking to prolong my phone just a bit longer, so maybe at this point I’m getting close to that upgrade. Still, can’t complain, this is a nearly 4 year old phone and it’s still going strong. If I use it a lot during the day then the battery will drain within a day, but other than that, it’s been an awesome phone so far.

Are Augmented Reality phones closer than we think?

The idea of a completely clear phone that you can look through and which projects data onto the world that you see through it’s lens is not completely sci-fi when you think about what we’ve seen already with products like Google Glass, and the upcoming Microsoft Hololens. Google Glass was not true augmented reality though, as it presented data to you in a screen to the side of your vision, and not presenting images blended into your normal field of view.

Oculus has been paving the way for the past few years with the development of their VR headset, recently being released in March this year (2016) after the company was bought by Facebook for a staggering $2bn. Clearly, there’s serious interest in the technology and application of VR. There’s been a number of different phone related VR headsets, like Samsung’s Gear VR developed by Oculus, the HTC Vive, and others. The upcoming launch of the Playstation VR headset set for October 13 could be the one that bring’s VR to the masses. At $399 (but requiring a PS4 console), riding on the Sony and Playstation brand this could bring VR into many households this holiday season.

A couple of stories recently caught my attention. Robert Scoble has recently been tweeting about an Apple patent for a completely transparent phone, a solid piece of glass, with the electronics tucked into a narrow strip a the bottom. The patent is from 2014,  but he makes some guesses in his longer post on Medium about where he thinks Apple are heading with this. Based on discussions with hardware and material suppliers he draws some conclusions about what he thinks Apple are planning. He also thinks a device using this technology might be coming much sooner than we think, as soon as September 2017. I won’t summarize everything he covers in his article, you can read it for yourself, but he does paint an interesting picture of the possibility of a tech giant like Apple making a serious move in the AR/VR space. Could Apple be about to bring this technology to everyday consumers, like they did for portable music players and the smartphone? Time will tell.

The second story from earlier this year is the $780m in funding raised by Magic Leap, a company developing AR related technology. Google is also behind $542m of this funding. What’s interesting about Magic Leap is that they’ve been largely off the radar, but have apparently developed a technique of realistically presenting images directly into the user’s field of view. They don’t yet have a beta product, and whatever they have in the works is being kept under wraps. Whatever they have, there’s definitely significant movement and growing interest in this space right now, it will be interesting to see where they’re going.