Erudite makes it possible to use Amazon’s Cloud Reader service under MeeGo. You can either read books online, or download them for reading offline. Your progress in a book is kept synchronised between your N9 and other Kindle devices.
Name change
Unfortunately since Amazon own a wide range of “Fire” themed trademarks, and the application’s operation is heavily related to the same areas that these trademarks are used in, Amazon couldn’t really let me carry on using the name “Firestarter”. It was entirely my own foolishness that caused this hassle by going for a “clever” name without even considering the potential trademark implications, thankfully the lawyer who got in touch with me was very understanding and patiently helped me work through the various issues. I’m just glad that Amazon handled everything so amicably, rather than wading in with heavy-handed legal threats as some companies might.
So from now on the application is called “Erudite”, a name that’s clever in a different way.
New features
Added in 1.2:
The application name has now changed to Erudite.
A number of buttons and menu entries have been made larger and easier to press.
You can now switch in to and out of fullscreen mode by pressing a toggle button in the bottom right hand corner of the screen.
Added in 1.1:
The application can now start up completely offline. You still need to be online for the very first usage and to download books, but once you’ve downloaded some books you can now always access them offline.
A progress indicator shows when the application is loading.
Keyboard bug is fixed. Previously you needed to tap on text fields twice to bring up the virtual keyboard, now it pops up on the first tap.
Erudite makes it possible to use Amazon’s Cloud Reader service under MeeGo. You can either read books online, or download them for reading offline. Your progress in a book is kept synchronised between your N9 and other Kindle devices.
With the (unexpected) release of Sviox‘s HTML widget runtime I thought it about time that I made my own efforts in that direction a bit more public. TizMee is designed to make it possible to run Tizen (and other) apps on MeeGo, supporting general HTML5 apps, apps using Tizen specific APIs and Cordova/PhoneGap apps (with some slight modification).
This first early release should support general HTML5 apps fairly well (although there are still a few that have issues), some aspects of the Tizen API (this is by no means complete however) and pretty much all of the Cordova/PhoneGap API.
It’s based around the QT Cordova port with Tizen specific functionality implemented as Cordova plugins in a mixture of C and javascript.
A number of test applications can be downloaded here: http://mikeasoft.com/~mike/tizmee/
To install them simply place their .wgt files in the TizenApps directory on your device (/home/user/MyDocs/TizenApps).
Thanks to Daniel Juyung Seo this post is also available in Korean.
Overview
Tizen has the capacity for native applications written using the Enlightenment Foundation Libraries (EFL), however in the 1.0 SDK release this functionality isn’t particularly well exposed. Instead the main focus is currently on HTML5/JavaScript based applications, which is fine, but it’s not appropriate for all applications. As a way to get to grips with Tizen in more detail I decided to try porting one of my existing applications, Eyrie, from MeeGo Harmattan (as used by the Nokia N9) to Tizen.
Eyrie is one such application which clearly isn’t especially suited to being written as a web app. It requires the ability to get raw audio samples from the microphone and perform some signal processing on them to extract acoustic fingerprints. As far as I can see the current Tizen Web API doesn’t really have the capacity to handle audio input at such a low level, and even if it did making use of it for Eyrie would involve completely rewriting the EchoPrint codegen library in JavaScript to handle the fingerprinting.
However by making use of EFL I was able to get the bulk of Eyrie ported to Tizen in less than 24 hours. Thanks to both MeeGo and Tizen using GStreamer as their multimedia framework and the EchoPrint codegen library being easy enough to compile for both platforms all that was really needed was a new UI using EFL instead of QML. Below you can see a video of the initial port running on the Tizen emulator (I don’t have a real device to play with at the moment), the UI is still a little rough around the edges but all the main functionality is working.
In this tutorial we’ll work through the creation, building, packaging and deployment of a very simple EFL application, which I hope will give people a handle on a potential workflow for native application development using the 1.0 SDK release.
Scratchbox
Although it’s not made obvious, the SDK actually contains a full scratchbox environment which the IDE drops into when build packages. While it might potentially be possible to write EFL apps purely using the IDE I found it easier to ignore this and jump into scratchbox directly, this then frees you up to make use of whatever editor/IDE you’re most comfortable with. If you are looking to work just within the IDE you might find the Tizen Platform Developer’s Guide a good starting point.
I’ll be assuming that you installed the Tizen SDK to ~/tizen_sdk/
Note: After installing the SDK it’s necessary to open the IDE and create (and possibly compile) a platform project. Simply select a new platform project and then hit compile. This sets up the scratchbox targets the first time around. You only need to do this once after installing the SDK.
Before we enter the scratchbox environment we should find out what targets are available to us. We can do this by running:
Since I’m working with the emulator in x86 mode I’ll be using the tizen-emulator-1.0.sb2_gcc45sbox2.i386.platform target, to compile packages for real devices you’ll need to replace this with one of the armel targets in the following commands. I’m unclear on the intended separation between the two armel targets, but I expect either should be usable for our purposes.
To access the scratchbox as your normal user you can simply run:
This is perfectly usable for building and editing packages, and you should find that your home directory is available within the scratchbox. However the rest of the environment will be mounted read-only, preventing you from installing new packages.
To start a session in which it’s possible to install packages we can run:
This mode is only really suitable for installing packages and isn’t usable for general development as most compilation tools aren’t available.
We want to try writing a simple EFL application using the Elementary toolkit, so to start with we’re going to need to install the Elementary development package:
apt-get install libelm-dev
As you can probably tell from the above scratchbox is a Debian based environment, so most of the normal Debian tools are available to us. So for example if we didn’t know the exact name of the Elementary package we need we could simply run:
apt-cache search elementary
And we’d get a list of likely looking candidates to choose from. As a side note the Eclipse based IDE does have a simple package management interface which can be found on the default toolbar, however this appears to lacks any way of searching for packages, but if you are trying to do everything through the IDE without dropping into scratchbox you might find it helpful.
Elementary
So now that we have a compilation environment capable of targeting both the emulator and real devices we can start writing our applications. For this tutorial we’ll just create a very simple Elementary application that displays a label:
#include <Elementary.h>
static void on_quit(void *data, Evas_Object *obj, void *event_info) {
elm_exit();
}
EAPI int elm_main(int argc, char *argv[]) {
Evas_Object *win, *bg, *box, *lbl;
/* Create our window */
win = elm_win_add(NULL, "eflexample", ELM_WIN_BASIC);
elm_win_title_set(win, "Tizen EFL Example");
evas_object_smart_callback_add(win, "delete,request", on_quit, NULL);
/* Give it a background */
bg = elm_bg_add(win);
evas_object_size_hint_weight_set(bg, 0.0, 0.0);
elm_win_resize_object_add(win, bg);
evas_object_show(bg);
/* Create a box to place our label inside */
box = elm_box_add(win);
elm_box_horizontal_set(box, EINA_FALSE);
evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0.0);
elm_win_resize_object_add(win, box);
evas_object_show(box);
/* Make a label */
lbl = elm_label_add(win);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_object_part_text_set(lbl, NULL, "Hello Tizen!");
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
/* Display the window */
evas_object_show(win);
/* Start the Elementary main loop */
elm_run();
return 0;
}
ELM_MAIN();
I’ll assume we’re working in the directory ~/src/tizen/eflexample/, so we can save this as ~/src/tizen/eflexample/eflexample.c
More comprehensive documentation on Elementary can be found on the Enlightenment Wiki.
We’ll keep the build process very simple for this example and just have a small Makefile handle compilation. For more complex projects both autotools and cmake are available.
This gets saved as ~/src/tizen/eflexample/Makefile
By including the $(DESTDIR) variable in our install paths we allow the Debian packaging we’re about to write to override the install destination and place it inside a temporary directory prior to being packed into a .deb.
If we run make in the ~/src/tizen/eflexample directory whilst inside our scratchbox session it should then compile successfully.
Launcher
You might notice in the earlier Makefile a couple of files that we haven’t yet discussed, com.mikeasoft.eflexample.desktop and icon.png. These are going to be used for adding our application to Tizen’s launcher. The .desktop file gets installed to /opt/share/applications/ alongside all other Tizen .desktop launchers, and should look something like:
Name=EFL Example
Type=Application
Exec=/opt/com.mikeasoft.eflexample/eflexample
Icon=/opt/com.mikeasoft.eflexample/icon.png
Comment=An example of how to write native EFL applications for Tizen
Version=0.1
X-TIZEN-TaskManage=True
X-TIZEN-Multiple=False
X-TIZEN-Removable=True
This is then saved to ~/src/tizen/eflexample/com.mikeasoft.eflexample.desktop
You’ll probably notice that there’s a selection of Tizen specific entries. The first, X-TIZEN-TaskManage, controls whether or not our application will appear in the Tizen task manager. The second, X-TIZEN-Multiple, tells the task manager if it is allowed to launch more than one copy of our application. If this is set to false the task manager will instead try to restore a currently running version of our application to the foreground. Because our simple example doesn’t perform the extra necessary work to allow Tizen to restore it to the foreground the task manager will instead simply kill our application when clicked a second time. Finally the last setting, X-TIZEN-Removable, specifies whether or not our application can be uninstalled through the application manager.
For the icon file we’ll simply use the Enlightenment logo:
Which needs to be saved to ~/src/tizen/eflexample/icon.png
Packaging
At this stage we could potentially just copy our eflexample binary to the device and start it via the command line, but a much more complete and redistributable solution is to construct a Debian package for it.
First we create our control file, which describes our package and its various dependencies:
Source: com.mikeasoft.eflexample
Section: user/other
Priority: extra
Maintainer: Michael Sheldon <elleo@gnu.org>
Build-Depends: debhelper (>= 7), libelm-dev
Standards-Version: 3.8.4
Homepage: http://blog.mikeasoft.com
Package: com.mikeasoft.eflexample
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: An example of creating EFL applications for Tizen
Architecture: any
This gets placed in ~/src/tizen/eflexample/debian/control
Because our build system is fairly standard and handles the DESTDIR parameter being passed to it we can use debhelper to automate all of our rules file for us:
#!/usr/bin/make -f
%:
dh $@
This is then saved to ~/src/tizen/eflexample/debian/rules
Then we have our changelog:
com.mikeasoft.eflexample (0.1.0-1) unstable; urgency=low
* Initial release
-- Michael Sheldon <elleo@gnu.org> Sat, 23 Jun 2012 04:32:27 +0100
Which is saved to ~/src/tizen/eflexample/debian/changelog
Finally we can specify which version of debhelper we’re compatible with by running:
echo 7 > ~/src/tizen/eflexample/debian/compat
Now we’re ready to actually build our package. To do this we need to be inside our scratchbox session as a normal user, which we achieve by running:
cd ~/src/tizen/eflexample
dpkg-buildpackage -rfakeroot
After our application has been successfully compiled and packaged it’ll be saved in the parent of our current directory (i.e. ~/src/tizen/).
Deploying
Now that we’ve built a package for our application we can deploy it using the sdb tool provided with the SDK. This should work with either the emulator or a connected device. First we transfer our Debian package to the device and place it in the /tmp/ directory, then we run dpkg on the device to install our new package. If we had used any additional dependencies that aren’t already installed by default we’d need to use apt-get to install them prior to installing our own package. However since libelm is part of the default Tizen system all we need to do is:
StatusNet for MeeGo makes it possible for Nokia N9, N950 and similar phones to connect to StatusNet compatible microblogging services such as Identi.ca. It supports viewing statuses in the phone’s event feed alongside Twitter and Facebook updates, viewing conversations, posting new status updates, replying to other people, following new users, favouriting messages and repeating messages.
New Features
Context menu for each message brought up through a long press on a message.
Retweeting/redenting of messages.
Favouriting and unfavouriting messages.
Following and unfollowing users.
Privacy policy.
New login screen.
Registration link on the login screen.
Fixes problem displaying statuses with no text in the event feed.
Eyrie is an application for the Nokia N900, N950 and N9 phones that can find out information about music that’s playing nearby. The latest version adds support for the N900 in addition to the N9 and N950. On the N9/N950 there’s now a graphical waveform displayed whilst recording and on both platforms music is assessed more continuously allowing some songs to be recognised faster and providing more chance for songs that were previously problematic to be recognised.
Eyrie is an application for the Nokia N9 and N950 phones that can find out information about music that’s playing nearby. It does this by making use of the EchoPrint algorithm to extract musical features from whatever you’re currently hearing. This is then used to find out the name of the artist and track from The EchoNest. Currently the database of songs accessible via EchoPrint fingerprints is a bit small, but it has the advantage of being an open database that anyone can submit fingerprint information to (although at the moment the process for adding new fingerprints isn’t very clear).
Recently I’ve spent a little time getting the Ogre3D engine into a state where it’ll work on the Nokia N9 and N950 MeeGo phones.
To test the port out a bit more extensively I decided it’d be a good idea to try porting an existing game, at which point rzr suggested Those Funny Funguloids. So after a fair amount of hacking to make it compatible with my version of Ogre and to make the controls work reasonably on a touch screen device I have a playable version.
The aim of the game is to collect mushrooms (…IN SPACE), and bring them back to your base without running into any asteroids. Only mushrooms of the same colour as your base are added to your score and your base changes colour each level (but you can hang on to mushrooms between levels and score them later). The controls are fairly simple, touch the left side of the screen to turn left, the right side to turn right and the middle to start moving.
When I have a bit more time I’ll see about writing a little tutorial on making use of my modified version of Ogre3D to create 3D applications and games in a way that’s easy to distribute.
A while back a wrote a little game for the Nokia N9 and N950, mostly as a way to explore the QML Box2D bindings. However, whilst packaging up my StatusNet client I thought I might as well release this as well since it can be a fairly enjoyable distraction. Below is a short video demonstrating how it works, and at the end of the post you can find details on where to get hold of it.
StatusNet for MeeGo makes it possible for Nokia N9, N950 and similar phones to connect to StatusNet compatible microblogging services such as Identi.ca. It supports viewing statuses in the phone’s event feed alongside Twitter and Facebook updates, viewing conversations, posting new status updates and replying to other people.
New Features
Support for followings links in posts.
Links to groups, tags, and users.
Support for posting messages using UTF-8 characters.
Slight improvements to the clarity of the login screen.
