Older blog entries for Elleo (starting at number 80)

Native App Development With The Tizen 2.0 SDK Article

An article I wrote a little while back for DZone about native Tizen development has just been published, in it I work through the creation of an application to identify music (similar in principle to Eyrie, although greatly simplified). It involves a brief look at the native user interface builder, use of the native sound capture and HTTP APIs, a small amount of audio processing and instructions on how to incorporate a general 3rd party GNU/Linux library into a Tizen project.

The full article can be read on DZone: http://css.dzone.com/articles/native-app-development-tizen

Syndicated 2013-07-31 14:34:00 from Michael Sheldon's Stuff

Erudite now available for Symbian Belle

Erudite displaying a book library

Overview

Erudite makes it possible to use Amazon’s Cloud Reader on various mobile platforms which aren’t officially supported by Amazon. You can either read books online, or download them for reading offline. Your progress in a book is then also kept synchronised between your phone and other Kindle devices.

Symbian Belle support

Until recently Erudite only supported MeeGo Harmattan and Mer based phones (such as the Nokia N9), but now it’s also available for Symbian Belle phones as well. I’ll also try and put together a build for Symbian Anna phones in the near future.

There’s a fairly comprehensive review of Erudite for Symbian over on All About Symbian: Erudite review.

Upcoming features

In the next release for both Symbian and MeeGo I’ll be focusing on orientation switching support, so users can optionally view their books in landscape mode, as well as investigating some apparent issues with very large books.

Download

  • Symbian Belle version — Nokia 701, Nokia C6-01, Nokia C7-00, Nokia N8-00, Nokia X7-00, Nokia E6-00, Nokia 808 Pureview, Nokia 603, Nokia Oro, Nokia E7-00, and Nokia 700
  • MeeGo Harmattan version — Nokia N9, Nokia N950

Syndicated 2013-04-19 09:51:34 from Michael Sheldon's Stuff

Ogre3D on Jolla’s SailfishOS

I spent a bit of time hacking around with the Sailfish SDK and managed to get a rough port of Ogre3D working:

Video of the Eyrie music identifier’s initial port to EFL on Tizen

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 drop 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/

Before we enter the scratchbox environment we should find out what targets are available to us. We can do this by running:

~/tizen_sdk/SDK/build-system/toolchains/scratchbox2/bin/sb2-config -l

With the 1.0 SDK release this produces the following output:

tizen-device-1.0.sb2_gcc45sbox2.armel.cdeb
tizen-device-1.0.sb2_gcc45sbox2.armel.platform
tizen-emulator-1.0.sb2_gcc45sbox2.i386.platform

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:

~/tizen_sdk/SDK/build-system/toolchains/scratchbox2/bin/sb2 -t tizen-emulator-1.0.sb2_gcc45sbox2.i386.platform

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:

~/tizen_sdk/SDK/build-system/toolchains/scratchbox2/bin/sb2 -e -R -t tizen-emulator-1.0.sb2_gcc45sbox2.i386.platform

This mode is only really suitable for installing packages and isn’t usable for general development as most compilation tools aren’t available in this mode.

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.

CFLAGS=`pkg-config --cflags elementary`
LDFLAGS=`pkg-config --libs elementary`

eflexample:
	$(CC) $(CFLAGS) eflexample.c -o eflexample $(LDFLAGS)

all: eflexample

clean:
	rm -f eflexample

install:
	mkdir -p $(DESTDIR)/opt/share/applications
	cp com.mikeasoft.eflexample.desktop $(DESTDIR)/opt/share/applications/
	mkdir -p $(DESTDIR)/opt/com.mikeasoft.eflexample
	cp eflexample $(DESTDIR)/opt/com.mikeasoft.eflexample/
	cp icon.png $(DESTDIR)/opt/com.mikeasoft.eflexample/

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:

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
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:

~/tizen_sdk/SDK/build-system/toolchains/scratchbox2/bin/sb2 -t tizen-emulator-1.0.sb2_gcc45sbox2.i386.platform

Then we can begin building our package:

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:

~/tizen_sdk/SDK/sdb/sdb push ~/src/tizen/com.mikeasoft.eflexample_0.1.0-1_i386.deb /tmp/ && ~/tizen_sdk/SDK/sdb/sdb shell dpkg -i /tmp/com.mikeasoft.eflexample_0.1.0-1_i386.deb

We should now see a new icon in the Tizen application launcher for our example app, which we can simply click to start.



Source

The complete source for this tutorial can be download here: eflexample.tar.gz.

Syndicated 2012-06-23 15:29:58 from Michael Sheldon's Stuff

StatusNet for MeeGo 0.3

StatusNet for MeeGo displaying new status menu

Overview

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.

Download

Direct download: statusnet-meego_0.3-1_armel.deb

Source

License: GPL version 3.0 or later
Gitorious repository: https://gitorious.org/statusnet-meego-plugin
Ohloh project page: https://www.ohloh.net/p/statusnet-meego

Syndicated 2012-06-14 19:32:45 from Michael Sheldon's Stuff

Eyrie 0.2 – Now with N900 support

Overview

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.

Video


Video of Eyrie 0.2 running on both an N900 and N950

Downloads

N9/N950

eyrie_0.2-1_armel.deb

Also available through the Apps For MeeGo Testing Repository

N900

Note: This requires the CSSU

libqjson0_0.7.1-1_armel.deb
eyrie_0.2-1maemo_armel.deb

Source

License: GPL version 3.0 or later
Gitorious repository: https://gitorious.org/eyrie/eyrie
Ohloh project page: https://www.ohloh.net/p/eyrie

Syndicated 2012-06-04 06:58:05 from Michael Sheldon's Stuff

Eyrie

Overview

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).

Screenshots


Eyrie start up Eyrie detecting Aimee Mann

Video