Today I was packaging a very first version of Mussorgsky in QML which requires the “TrackerReadAccess” token (to query Tracker via dbus). So far I have been working in the command line tool where a aegis-su -r TrackerReadAccess python mussorgsky.py was enough. But how to do the same when the application is installed?

1. Create a $PACKAGE_NAME.aegis file under your debian/ directory. There you need to declare what tokens you want for what binary. Example: in mussorgsky.aegis I request “TrackerReadAccess” for “/usr/lib/mussorgsky/mussorgsky-qml.py”, which is the executable that starts my program.
2. Put the aegis file in the package. Using CDBS is almost the same as in C++, without the include of autotools.mk:
   
   # Add this to the debian/rules file
   PACKAGE_TARGETS := $(foreach pkg,$(DEB_ALL_PACKAGES),binary/$(pkg))
   $(PACKAGE_TARGETS)::
   [ ! -f debian/$(notdir $@).aegis ] || aegis-deb-add -control \
   debian/$(notdir $@)/DEBIAN/control .. debian/$(notdir $@).aegis=_aegis

3. Make your package build-depend on aegis-builder (>=1.4)

Then you build your package. It should install nicely and your application run without problems on the device. Still, a couple of remarks:

• The token must go to a executable script (with #!/usr/bin/python on its first line). python myscript.py will not work. The path is absolute.
• After installing the package, do NOT modify the installed files if they request a token. Security FW will discover an unexpected change in the file and lock the device (ops! reflash). Imported files and other resources can be modified.

Happy hacking.

6 0

If I understand correctly what OBS does, it should be fairly easy. Create your OBS “area”, upload your package, try to build it against the different MeeGo versions and when it is ready publish the URL of your repository with the result [This is not trivial. Is it possible at all?]. Once the things are properly tested, promote that package to a common well-know repository and we all are happy.

That is not the situation now, but that didn’t stop the community to package some very useful software. You just need to dig in “underground” repositories. To save some browsing time for other users, here are my two favorite repositories:

• Community repo with mplayer, xchat and gstreamer plugins (to play all those formats unsupported in the vanilla installation)
• Madeo (arfoll) repo with XBMC, a great media center that works nicely in MeeGo… (it deservers its own post)

Other interesting software like Transmission is in the official repos, and MeeGo is a plain linux inside, so the official sopcast client for linux works just following their instructions.

More sources for packages are welcome as comments. Hope this helped.

6 1

The plan is to talk about what Tracker does NOW in a very pragmatical way, explain the limits we have hit, and give a hint on the more or less experimental ideas we have for the future. Less philosophy, less history and much more pragmatic information, compared with my previous talks. Believe or not, I won’t mention “RDF” or “ontology” at all.

Tracker is nowadays ready to use, and Meego (even if it is only for 1.2) will be the first environment where all its potential can be shown with real information. Combine this with QML and pyside (python bindings) and everything is in place to write very easily surprising applications.

7 0

From now on (it has just landed in master), Tracker libraries are accessible via gobject-introspection. You can manipulate the information via libtracker-sparql or write new miners using libtracker-miner in any language with gobject-introspection support (E.G. python). A snipped of code is worth a thousand words:

#!/usr/bin/env python
import gi
from gi.repository import Tracker

conn = Tracker.SparqlConnection.get (None)
cursor = conn.query ("SELECT ?u WHERE { ?u a nie:InformationElement. }", None)

while (cursor.next (None)):
      print cursor.get_string (0)

This is a synchronous query to the store. Note that you have a cursor to access the results: they will be retrieved from the DB only when needed. Using this while building a model for the UI should show quite a performance improvement compared with the old DBus API. And if you fancy more the asynchronous way of coding, the code looks like this. You can open the connection, run the query and retrieve the results all asynchronously.

When it comes to miners (processes retrieving information), here is a skeleton of an implementation: a subclass of Miner overriding few methods. Install with the usual dbus files and you have a miner that can be started/stoped/monitored with the Tracker tools.

libtracker-sparql is our recommended way to use tracker, the DBus API can be considered internal, and now with gobject-introspection it is available from different languages than C or vala. Combine this with libpeas (also using GI) and then we can easily write plugins showing information from Tracker into applications like EOG or totem… Interesting!

7 0

If you have used it, and think it passes the Q&A checklist, please give mussorgky some karma!

11 0

This was a good change in a lot of senses, but it was breaking our functional tests. We have a suite of tests that we like to run once Tracker is installed in the system. They check if the basic functionality is working fine: the store starts, the miner starts, basic Sparql is processed fine, crawling/monitoring a directory is ok… Some of those tests rely on booting tracker with an specific configuration and with gsettings that isn’t as easy as defining a new XDG_CONFIG_DIR anymore. Well, lets fix the tests then.

My first idea was to hack our GSettings object to load data from the system or from a keyfile, depending on an environment variable: very portable, but is an ugly hack and the code paths start to differ a lot. Then i discovered the DConf profiles. Only works when gsettings is using dconf and needs to install a system-wide profile, but otherwise (in code and test setup) is nice.

It took me more time than expected due some stupid mistakes here and there using dconf:

• Profile names can only use alphanumeric and underscore characters. A profile like “tracker-test” won’t work (because is not a valid dbus name), but “trackertest” is fine. (Wiki updated now)
• Do NOT set XDG_CONFIG_DIR in the environment (Bug reported). I guess that the client is using the variable to look for the DB but the writing daemon is not, so the results are not the expected
• If at the same time you are changing the dconf schemas, make sure to remove old files from /usr/share/glib-2.0/schemas, run /usr/bin/glib-compile-schemas /usr/share/glib-2.0/schemas and remove any old dconf database (in ~/.config/dconf) including “user”. Otherwise if some code is using the old schema, it won’t complain but the values will be wrong.
• DConf uses the GVariant serialization, so be careful when setting lists.

I hope this saves some time to the next person trying to test something that uses dconf for its settings.

5 0

It is a plugin for Tomboy (a NoteAddin in their terminology) that writes the information of the note into Tracker making it searchable on the desktop (E.G. using tracker-needle). The code is available in gitorious. Checkout, compile and install (you can use make install-data-local in src/ to install it on your $HOME). Well, you also need the latest tracker from GIT until we release 0.10.2 (soon) because i needed to add a “Note” class there.

The current status is “It works on my computer” but is safe to try because this plugin only exports data and never touches the original notes, so there is no risk of losing any information. Feedback is very welcome!

9 1

What is new?

• Fixed bug #8912, crash editing some songs (thanks to the reporter and patient users)
• Added support for internationalization (thanks to this tutorial and few bits of code from ReSiStance)
• Translations to Spanish, French (Eric Le Roux), German (Marius Vollmer), Finnish (Kimmo Hämälainen), Galician (Xabier Calvar) and more to come…
• Fixed the album art path calculation, now albums with special characters in the name are set correctly and appear in the media player
• Support for WMA, OGG and FLAC (the merits go to mutagen).
• A brand new cool icon, more maemo style, thanks to Urho Konttori:

Enjoy and as usual, feedback is welcome. We have a bugzilla component (under Extras/Mussorgsky) to report issues.

By the way, If you have a project in python and wonder how to add i18n, give a change to this wiki page: how to internationalize python apps in maemo; i tried to write there as clearly and simple as possible how to do it.

10 0

• By default mussorgsky uses “artist + album” to search online for the album art. Now it is possible to choose manually the search string to find better results:



• Added the alternative to unset the album art, reverting it to the default icon
• The list of songs can be filtered, switching between “all songs” or “songs with incomplete metadata”
• Albums with special characters in their name (like ‘&’) are now handled correctly.

And few UI improvements here and there:

• The buttons in the main screen have now shadows with rounded corners when clicked
• The play, next, back buttons in the edit view come from the mediaplayer theme
• When a song has no metadata at all, it is listed using its filename

It is already available in extras-devel, hope you enjoy it. And finally, thanks to Eric, Aapo and Claudio for their very valuable comments and help!

19 0

Tracker and Zeitgeist are complementary projects: Tracker knows the documents, Zeitgeist knows the activities. We (tracker developers) have been talking with Zeitgeist developers before and have a common understanding about the big picture. Now is time to start fixing details, and I’ll be next week in the Zeitgeist hackfest to work on that.

By the way, with some patience and fixing few details, Zeitgeist and Tracker 0.7 can be installed in maemo5. Catching few events here and there, zeitgeist can grab some basic informacion, and somebody could write a Journal home-screen applet, like the call log, but about all kind of activities/documents… Quite an interesting project.

5 8

So, the first talk (in an informal event between organizers and speakers) was about the N900 and some Q&A about it and maemo5. The people were mainly linux enthusiast, so lots of good questions about how to develop on it and the technology involved.

The first of the official talks (during the GNOME day) was about maemo5, what is it, relation with the desktop and how to contribute. I explained also one of the coolest things in maemo (IMHO): all the extras-devel/extras-testing/extras process. Your pet-application (or not so pet when you spend hours and hours on it) can easily reach a lot of users in few clicks. Well, few clicks on your side, and few more on the community side.

The second and last talk was about Tracker. The usual introduction to the basic concepts, and a couple of demos. I was happy to show that using tracker you can get “The last blog post of the user who sent me this song”. Sounds like a lab example, but it mixes RSS, contacts, files and activity, and you can easily see a plugin in totem using this.

About the event itself, the audience was more on the university side of life and people using free software in their companies/work; so a lot of curiosity for new projects and general conversation about open source. There were some people looking for a place to contribute in GNOME; I gave them few hints how to do it via tracker (e.g. writing plugins to Eye of GNOME), so let see if we get fresh blood in the community.

Finally, i want to say thanks to the organizers there, from Encuentro Linux and GNOME Day. They made everything easy, treated me really great, showed me a little bit of Chile and made me feel really warmly welcome. Thanks, guys!

9 2

We have only 25 minutes and too much to explain. If you are curious about Tracker, what can it does (and what not), how to use it in your application, or how you application can get advantage of it, you have 3 regular contributors (Iridian,  Philip , and me) in the conference; feel free to come and talk with us. We are always happy to explain to the world what this triplets, ontologies, RDF mess is all about.

6 0

This time the changes are mainly on the UI:

• New main screen using fancy big buttons. Thanks to Gabriel Schulhof for his help translating the C version of this custom widget (in hildon-application-manager ) to python!
• All songs are arranged now in a big list with interactive search
• Fixed thumbnail location, so MAFW uses the thumbs generated by mussorgsky.
• Now an album with multiple artists appears only once in the albums list

And few more things here and there. As usual, feedback is welcome.

5 0

Changes mainly in the album-art part of the program:

• Allowed to choose manually the album art for a specific album
• Moved “Automatic retrieval” of album art to a menu option
• Better information in the automatic download dialog
• Changed the first screen layout/buttons and added a window for the album art.

On the technical side, more things are asynchronous and i discovered how elegant is the code using the “yield” statement. As usual, feedback is welcome.

7 0

It was a pretty active week, starting with my talk on Sunday in the cross-desktop track (slides). I explained there what did we do in tracker 0.6 , and what do we plan for tracker 0.7. This can be interesting for maemo-fans, as far as tracker 0.6.9x is the version available in Fremantle, and 0.7 is in the roadmap for Harmattan.

During the week, i was talking with some of the Zeitgeist project people. In few words, Zeitgeist will monitor and store the activity of the user, analyze it and extract relations between documents, applications, tags, etc. (E.G. “every time i edit doc1, i read webpage2″). Tracker has already the information about documents and applications, so instead of building their own database, they can set the “relations” directly into it. Zeitgeist is one of the hype projects now in GNOME and i am very happy to see Tracker participating in such an ambitious idea. [Note for hackers: if the things work fine, be ready to write a maemo UI for it!]

Taking advantage of the Akademy-GUADEC co-location, we (tracker team) also had an informal meeting with Sebastian Trueg, from the Nepomuk-KDE project. We are sharing ontologies and we agreed on how to distribute them and organize the documentation. The idea is to have a shared-desktop-ontologies package for all desktops and platforms with the nepomuk core ontologies, allowing applications to install extensions.

And finally after some parties and more talk with developers, i had another presentation in the Spanish GUADEC, explaining again tracker (slides in spanish), but this time showing the tools, code and examples.

I expect to see some results (i.e. more information into tracker from different apps) sooner than later. Stay tuned!

2 3

In fremantle/maemo5 we have tracker to retrieve the information of the music files and make the life of Music Player developers easier. It is really cute to browser your music “by artist”  but in my case (and i guess i am not the only one) the metadata of my music files is far from perfect and unified (songs without title, without album, misspellings in artists names, no album art at all and so on). There are a lot of programs out there to fix this problem (e.g easytag) but they all require a PC, and i want to edit this stuff directly on the tablet!

So, here comes my pet project “MussOrgsky”: a small application to set the basic metadata of the music files (title, artist, album and album art) directly on the device.

This is the edition window (the main window can be seen here ):

It is an python program that uses:

• the new hildon widgets for maemo5 (there is a really helpful tutorial!)
• tracker to query the availabe music data (or absence of it),
• mutagen to write the information back into the files (i uploaded the package myself to extras-devel few days ago)
• gstreamer to play the files (yes, there is a “play” button to help you to know what damn song “gtkpod0123123.mp3″ is)
• Some online search engines to retrieve the album art
• It follows the media art storage spec (using Urho’s implementation), so UKMP, MAFW, and this editor share the same album art

You can find the source code in garage.maemo and the package to install in extras-devel. I have still some ideas pending to implement, but it should be usable. As usual, feedback is welcome!

15 0

No. it won’t work.

For some reason, inside scratchbox some paths are modified and the final .deb package install the files under “/scratchbox/tools/bin” and “/scratchbox/tools/share” (instead of the usual “/usr/bin” and “/usr/share”), so the package is somehow installable in scratchbox but useless for the real devices

I didn’t find any solution on the net, and It took me quite some time to figure out how to solve it. After a hundred tests with different CDBS rules and combinations, it was so easy as add a setup.cfg file on the root of my project with this content:

[install_scripts]
install_dir=debian/<package>/usr/bin

[install_data]
install_dir=debian/<package>/usr/

After that, “dpkg-buildpackage -rfakeroot” generates a correct package, that can be uploaded to extras!

13 0

The next step will be to move our work for the new tracker (SparQL, signals,…) from the codethink git to the gnome repository. Then we can work on the merge of both branches to make 0.7.x the main development line with as few regressions as possible.

The plan is to use the 0.7.x numbers for unstable (soon and often) releases and 0.8.0 for the next stable release.

4 1

While still improving the 0.6.9x version of tracker for Fremantle (last week we released 0.6.91 with tons of bugfixing), we are also working on the 0.7.x plans. Philip has already described in detail what are we doing, and i think the most exciting feature is going to be the “observe changes about resources”.

The problem is easy to explain: you write your application (e.g. email viewer), populate its views with data from tracker (e.g. “last 10 emails”), and then… how does your app know when is a new email has been received? It does so because maybe evolution has already pushed a new one into tracker!

Obviously “polling” tracker every n minutes is not a solution, and the nice live queries are very complex and hard to implement properly. BUT we have come up with an easy solution that can help.

The applications will subscribe to an object (or more) in DBus (one object = one class in nepomuk), and then they will receive a signal when something happens in that category with the relevant URIs (e.g. an email is deleted in Emails category, a music file is added in Music class, a document updated, and so on). With this information, the app can decide what to do (e.g. deprecate the view, ignore it because now it is showing other info, query tracker about the relevant metadata, …) .

In coding terms: your email viewer will ask “last 10 emails” and subscribe to signals from “/org/freedesktop/Tracker/Resources/Classes/nmo/Email”. Then when a new mail enters the mailbox, the app will receive a signal “ChangeAdded ([list of tracker uris added])”. Here are some more details of the design.

Once we have this mechanism in place, it will be easier to use tracker as backend for user data in the applications: a nice query language + update notifications! It will also allow us to switch into a model where providers (e.g. a feeds monitor, browsers) push info into tracker, and completely independient applications just query it from there… and then to write a mashup app would we soooo easy… and….

P.D. Philip told me: “before you blog about this, it will be implemented”. Well… if i waited one more day…

10 0