MyMoves 0.0.2: Usable gestures for Harmattan


MyMoves version 0.0.2 is now out. The previous version was a hackish demo which didn’t contain a proper UI
for normal usage. This version does : ) Also, recording the gestures with a clumsy UI wasn’t the nicest
thing on earth, so I settled for having 12 pre-defined gestures, which should all be simple enough to
be recognized with different users.

In order to avoid disturbing normal usage of the phone, there are 6 two-finger and 6 three-finger
gestures, and no single-finger gestures at all. In addition to that, there’s pinch recognition for
avoiding accidentally opening an application while zooming in or out. Currently it handles most of the pinches, but there’s still a couple of glitches to fix, such as it doesn’t yet catch zooming of web pages 100% of the times.

Here are the gestures:

Most significant changes:
– Simple configuration UI for selecting an app for each gesture
– Option in the UI to start/stop observing gestures
– 12 preconfigured multi-touch gestures
– Pinch recognition to avoid conflicting with normal usage
– Auto-start of the recognition server on boot and after installation

Installation is now available via a repository, so enough for copying stuff into the phone manually : )

Instructions for installation (run as root):
1. In case you have the previous version of mymoves installed, remove it from the command line:
dpkg -P mymoves mymoveserver

2. Add the mymoves repository to your phone:
– Create a file called /etc/apt/sources.list.d/mymoves.list
– Into that file, enter this line (without the quotes): “deb binary/

3. Make sure you’ve got a working internet connection on your phone

4. apt-get update
5. apt-get install mymoves
6. Ready to run!

Have fun with the app! : )

For the interested, sources are in GitHub:
The UI:
Server side:

Here’s a demo clip of MyMoves 0.0.2 in action:

EDIT: Thanks to a question in Youtube, decided to make another small demo to show that you can also use the gestures in the lock screen. The system forces the lock screen on top, but it still opens an application ready for you to use : ) The clip:

I see some Raw Motion. \o/

Quick update.

Read a great set of XInput2 blog posts by Peter Hutterer and fiddled around with the code examples,
and the end-result is nice: System-wide multi-touch events!

So. Next up in the MyMoves roadmap will be refactoring it for multi-touch support.

N950 is getting 6 simultaneous touches, will that be enough for gestures?: P

Introducing MyMoves: system-wide gestures for Harmattan

Hiyouall! I’d like to demonstrate the results of the small 3-day home hackathon I ended up having : )

(Links to sources and .debs in the bottom, I recommend reading through first : P )

It’s a thing called MyMoves. MyMoves is an attempt to bring configurable
gestures to Harmattan, written in QML/C++. The idea of MyMoves is to be able
to create a gesture, and attach an arbitrary shell command into it.

The current prototype of MyMoves consists of two parts:
– mymoveserver, handles the touch events via XRecord, saves the gestures and performs the recognition
– Configuration UI for adding new gestures and starting/stopping the gesture observation
The server is controlled by the configuration UI via D-Bus commands

So. What on earth can we do with this? Let’s take a closer look. Here’s the configuration UI:

It consists of three buttons: “New Move“, “Start observing gestures“, and “Stop observing“.
The first thing to do is to is to create new gestures. Pressing “New Move” shows the screen for adding a gesture:

It’s a very simple screen with a box where you draw the gesture (it’s a QmlCanvas btw)
and buttons for saving and clearing the gesture box. Here’s one drawn gesture:

Let’s take a look at the video on how adding gestures goes:

Now that the gestures are set up, it’s time to attach them to shell commands,
which currently means getting dirty with the terminal. The gestures are saved
into files called mymoves[number] under /home/user/MyDocs/moves. Each
gesture has the shell command and the gesture data, so the start of a gesture file looks
something like this:

Add your command here
-128 430
-105 436
-95 441
-76 447
-57 455
-38 460
-21 466
-2 474
14 479

Now we can just edit the file, and add the command we want to run
on that specific gesture, let’s say e.g. the calendar, so we replace
Add your command here
/usr/bin/invoker –no-wait –type=m /usr/bin/organiser -showWindow 1 &

The command needs to be added just like to a command to a terminal, so no quotes.
Make sure to add & to the end of the command, so it’ll start in a non-blocking way.
Also, the MyDocs folder is in users possession, so use su – user to get permissions for editing the files.
Do that for each of the mymoves[number] files, and you’re set up!

Now using the gestures is as simple as firing up MyMoves and pressing “Start observing gestures“.
Here’s MyMoves in action:

Enough for the talking! Where can I get it?

Source code:
Harmattan debs:

Installation only via command line. SSH to your phone, copy the .debs under /home/user/MyDocs,
and run dpkg -i mymoveserver_0_0_1_armel.deb mymoves_0_0_1_armel.deb.

Plans for the future:
– Making the server more robust
– Decoupling the server from the configuration UI so that it starts from the boot
– A usable UI for configuring everything (such as dialogs for selecting an application to run on a gesture etc)
Multi-touch gestures : )
– anything else that pops into my mind

Have fun! 🙂

FunkeySynth 0.12.1 for Harmattan available

Hi all!

Tagged a new release of FunkeySynth for N9/N950. Main changes since version 0.12:
– Recording&playback of 16-sec loops
– UI for the 3 additional oscillators
– Support for algorithms (different routing for the oscillators)

Download the latest .deb from

Please note: if you haven’t got portaudio already, install it from the above location too!
Installing goes the traditional way via command line:
Log in as root, copy .debs to /home/user/MyDocs, dpkg -i package.deb for each package

For loop support, there’s a new record/playback button in the main screen:

Functionality of the button:
– Press once -> it goes to ‘ready for recording’ state
– Start playing the keys -> recording starts
– Press again to stop recording
– Now it’s a play button. Press to start/stop playback of the loop
– Long-press to clear the loop from memory. The button returns to the initial state

Another big update, a new screen for adjusting the additional oscillators:

With this screen, you can adjust various properties of the oscillators,
such as attack, decay, sustain, release, and wave type. Also, there’s an
algorithm selection button available (the black&white thing with numbers).

The algorithm selection button controls how the signals from the oscillators are routed,
e.g. in the screenshot above all of them are in series. This means that oscillator 4’s
output is fed into oscillator 3, oscillator 3’s output to 2, and so on. Oscillator 1
is the ‘main’ one, dynamics of which you can control in the main screen.

In total, there are six algorithms available, varying between having all the oscillators
in series to having them in parallel, where it’s just four signals summed to get the output.

Below is a demo video of the new updates. It demonstrates the use of
the algorithm selector and the looping. You might not notice too big difference
between the different algorithms via the video, the best way is to experiment
with the app yourself and see what kind of sounds you come up with.

(Disclaimer: Playing touch-screen keyboard with one hand is hard : P)

OperaMobile 11.00 for Harmattan

Noticed a tweet from zehjotkah about OperaMobile on Nokia N950,
which points to a tutorial by XeN.
The version running on N950 is the same as Opera’s developer preview for MeeGo ARM.

Since the tutorial’s version copies files to the handset manually, the uninstallation has to be done manually too.

So. Therefore I decided to quickly create a Debian package for the OperaMobile developer preview : )

Please note: this is NOT an official .deb or anything, but a temporary way of using OperaMobile in our N950’s until Opera comes out with an official OperaMobile release for Harmattan.

You can grab the .deb here:

Install with the traditional dpkg -i operamobile_11.00-1_armel.deb.


FunkeySynth 0.12 for Harmattan

It was time to tag version 0.12. Most significant changes:
– A better-looking icon
– Envelope controls (attack, decay, sustain, release)
– Volume control
– LFO (Low-Frequency Oscillator) with frequency&amplitude controls

Bugs that need to be fixed:
– Occasional crashes when playing the keyboard fast
– Start app -> Bend on -> Press a key -> Note keeps playing
– Robustness to the keyboard (sometimes they get stuck)

Download the .deb for your N9/N950 from here:

Demo video:

FunkeySynth enters Harmattan!

Received my N950 yesterday, thanks to Quim and everybody working with the N950 Developer Device Program!

Today started tweaking the FunkeySynth UI from the tablet environment into smaller devices (N9/N950). Was expecting some glitches, as the synthesizer code is not optimized and the amount of resources available are naturally smaller than in a tablet. However, I was in for a nice surprise: it’s working smooothly. : )

There’s a lot to be done, the UI has to be redesigned from a 10-inch screen to 4 inces. Started with a simple cleaning of the main screen to contain only the keyboard and the most important buttons, so the focus would be on playing and editing basic characteristics of the sound. The more complex sound synthesis configuration will go to a separate screen, the sliders seen in the tablets have to be converted to rotatable knobs to save space etc. But thanks to QML, there’s a good start already.

You can download test .debs for PortAudio and FunkeySynth from here.

Here’s a small preview on what will be coming:

FunkeySynth goes Multitouch

Even though QML’s multitouch support isn’t included in the official releases yet (correct me if I’m wrong), there already are projects on MeeGo (such as Mong) that utilize multitouch with QML. Since having multitouch support in a synthesizer application is quite essential, decided to cook it up. Noticed that the Mong guys are using the QML TouchArea component, which can be found via e.g. this Qt Labs post from February which provides a link to the QML TouchArea component in Gitorious. Coding the UI part with the TouchArea component turned out to be rather easy, adding duophonic support to the sound engine side needed a bit more tinkering. However, finally, the multitouch support is done! : )

Code can be found in Gitorious:

If you want to try this out in your MeeGo tablet, head to

From the above repository, install portaudio-<version>.rpm + com.sandst1.funkeysynth-<version>.rpm and enjoy!

A demo clip:

It Does run on N900 DE too :)

Wheee. Just after packaging FunkeySynth as an RPM, noticed that OBS popped out an ARMv7 build as well. First thought after that: “Hmm…How well would this run on the N900..?”

The UI is designed for a larger screen so the layout is not pretty, BUT it works : D

If you’d like to try this out on your N900, grab the RPM’s from here:

Installing FunkeySynth to your MeeGo device

After pushing the code to Gitorious I decided to wrap the application into an RPM so people can try it out themselves.

Installing FunkeySynth with Zypper:

Alternatively, you can download the portaudio & funkeysynth RPMs from here

and install the app with

  • rpm -i <portaudio.rpm>
  • rpm -i <funkeysynth.rpm>

Have fun!