It has been a long time since I posted a blog (1 month+). In fact it might even seem the Krita ran on Android and now GSoC is done. Well, not quite. There’s still a lot to be done.
Let’s see what we worked on :)
First and foremost was managing the build. If you have a look at
README.android, you will see that’s a bunch of environment variables and few steps. If you look at underlying code, it was even uglier with lots of boiler plate. So, we had to refactor it and we did and made the build system a bit pleasant. (
Next, was a bug in the OpenGL canvas, when we enabled hardware acceleration, the canvas would turn black.
QPainter being painfully slow, so it certainly isn’t the option, so we really rely on OpenGL ES.
So we had to fix this, it took me quite some time to fix and the solution was simple in the end.
Results? We can draw on OpenGL canvas now!
If you have played any heavy game on Android, then there is one thing which you might know. If you leave the app and come back after a few minutes all the progress is lost or the connection to the server is terminated (it happens less often with new devices having a lot of memory).
This could happens with Krita as well, so now as soon as we get
Activity#onPause(), we call the JNI wrapper
Java_org_krita_android_JNIWrappers_saveState to save the state synchronously.
I did try to save it asynchronously (which uses slots and signal), but I found out, as soon as the main Qt thread was paused, the entire queued connection mechanism was brought to halt.
For past week, I have been working on adding touch support to the canvas. What I mean by touch support is, to handle “finger paint” events and we’ve been successful in doing so. We can now draw on canvas now, using our fingers, not just a pen!
To do this we simply consider the touch events with one touch point as mouse click/update/release events (the same way we do this for tablet events).
But… there is a difference!
Krita did support touch drawing on touch screen windows/linux laptops. So, why didn’t it work for android devices? In windows, if
QTouchEvent wasn’t handled, Qt would automatically generate
QMouseEvent for it. But the same wasn’t true for android.
There is a way, however, to simply ignore touch events and use mouse events, even for android (by manipulating
Qt::WA_AcceptTouchEvents flag). This wouldn’t work for Krita because we still use touch events to rotate/zoom/move canvas. So, we now explicitly handle touch events.
We can now rotate the canvas using gestures! A small clip: rotation-canvas
It was pretty simple as well. First the way
KisTouchShortcut::match worked, wouldn’t allow both zooming and rotation to co-exist, because it distinguishes the different
KisTouchShortcuts based on number of minimum and maximum touch points. For both zooming and rotating, it was two.
So, for them to work in harmony, I created another class,
KisZoomAndRotateAction, which delegates the call to
KisRotateAction, we just find out the angle between the lines. Line being, “the line” passing through the two touchpoints on the canvas.
So, the two lines are:
- Initial position of fingers
- Final position of fingers
(this is a bit hard to explain, please look at code).
That's all! Thank you for reading, I’ll try to be more regular with my blog now :)