A Quick Look at Extras in Bugzilla
2012-02-27 through 2012-03-04

Front Page

Enabling Google Talk video calling on Nokia N9

With the release of PR 1.2 comes a very welcome software addition - Google Talk Video Calling. Simply download the application from the store and it integrates with your existing GTalk account. Initiating and receiving calls worked well in your editor's testing.

Read more (meegoexperts.com)

In this edition (Download)...

1. Front Page
   • Enabling Google Talk video calling on Nokia N9
2. Applications
   • Visual updates for gPodder on N9 under development
   • Open source Password Generator for N9 available in Nokia Store
   • Drop Cache for N9 flushes disk cache, preventing data loss and freeing memory
3. Development
   • Mer-based IVI Hardware and UIs
   • Penetration tools for Harmattan
   • Hardware accelerated OpenGL ES on N9 in Java VM
4. Community
   • Intro to Tizen and the Future of the Community: Dawn Foster's FOSDEM talk slides
5. Devices
   • Problems installing N9 apps or updates?

I’ve just released the 0.0.2 version of Applications Fullscreener and Automatic Skype Launcher.

As I was already commenting in my previous post Extending the life of your N8x0: Automatic Skype Launcher, just download them and install them in your N8x0 for making it become a good 24/7 Skype phone.

The most important change for Applications Fullscreener is:

• I’ve added a helper to launch a certain application and send the fullscreen key event some time afterwards.
  This is specially useful for launching an application through the DSME watchdog daemon in Maemo4.x. Using this helper as a wrapper, the application will receive the fullscreen event some time after being launched while the watchdog keeps track of the helper. In this case, if either the helper or the application dies, both die and, hence, the DSME will relaunch them both.

You can, also, check the complete ChangeLog for Applications Fullscreener.

The most important changes for Automatic Skype Launcher are:

• I’ve added a Control Panel plugin for setting several behaviors of the application: starting an init service, using a watchdog for keeping it alive, trying to fullscreen Skype after launching it as a service and the time at which the service will be restarted, if so.

• I’ve added a Home Desktop applet for making it easier to launch manually Skype, not having to get into the applications menu.

• The Automatic Skype Launcher service was not stopping when the N8x0 was turned off while charging. Now this is corrected.
• In the previous version, I added a cron.daily script to restart Skype (and the service). Actually, the N8x0 doesn’t have a cron daemon, by default. This is now corrected through the usage of an alarm triggered by the alarmd daemon.

You can, also, check the complete ChangeLog for Automatic Skype Launcher.

That’s it. Comments and patches are welcomed!

PySide, the Python Qt binding framework used prominently in MeeGo 1.2 Harmattan, has now finished migration from its previous standalone setup to Qt Project infrastructure.

Being a Qt Add-on provides PySide a permanent home and perfect alignment with Qt Frameworks. Furthermore, the project gets improved visibility, as well as a simple, carefully thought out meritocratic project structure. In addition to the wiki that is already hosted by Qt, the PySide mailing list and the bug tracker are also now hosted by Qt. More information on the Qt Project can be found on the project web site.

The PySide project now follows Qt Project's governance model. The Maintainer for API Extractor, Generatorrunner, and Shiboken is Marcelo Lira. The Maintainer for the PySide component is Hugo Parente Lima. Paulo Alcantara is an Approver for PySide. All other project roles are informal. Srini Kommoori has kindly volunteered to be the webmaster and wikimaster for the project.

To developers using PySide the migration is mostly transparent. PySide is still available under the same licensing terms, and the project facilities are still the mostly unchanged. Instead of having a separate Bugzilla instance, the PySide project now utilizes Qt's Jira bug tracker. Also the mailing list address has changed to pyside@qt-project.org.

Qt Project uses Gerrit for code reviews. Developers contributing code to PySide should do it using Gerrit from now on. Read-only access to the git source code repositories is still provided via Gitorious.

About PySide 

PySide is a Python Qt bindings project initiated by Nokia. PySide provides access to not only the complete Qt framework but also Qt Mobility, as well as to generator tools for rapidly generating Python bindings for any C++ libraries.

The PySide project is a Qt Add-on, sharing the same infrastructure and governance model as the open Qt Project itself. PySide is developed in the open, with all facilities you would expect from any modern open source project such as all code in a git repository, and an open bug tracker for reporting bugs.

 

Last week, we got Mahjong Solitaire for N9 finally published.

This has been a great opportunity to use QML in my daily work at Igalia, instead of using it simply for the occasional hacking, such as Butaca or the XKCD reader.

So far, comments in the Nokia Store have been really positive -although some people seem to miss the classic theme from the Mahjongs available back in Maemo. But not only the comments are positive: the application is currently listed in the first position of the Top Free games!

Drop me a line (spena at igalia.com) if you find issues, you have suggestions or if you simply want to complain about the colors

Firefox for Mobile Geolocation V2 removed from Gecko - http://dougturner.wordpress.com/2012... March 7, 2012 from DougT » mozilla - Comment - Like

I now have libferris on a 512mb ARM5t embedded device and a 1gb arm7 one (the Nokia n9). As part of the fun and games I updated the clucene and boostmmap index modules for libferris and created a QtSQL module which uses SQLite by default. Hey, when you can't choose which cake to have why not have a slice of them all... or a slice to fit the moment or device at hand. eg, desktop or server works nicely with the soprano or postgresql indexing modules, embedded is nicer on mmap or clucene.

Adobe is just insane.

I'm again having some time and space in my mind to look at the world around me. A huge work related milestone was reached today. Something ended and something starts. It's a really big shame that the things that do succeed in my new position are definitely something I would not be able to share for a long long time with anybody outside of Nokia.

I wrote some time ago about how insane the flash 11 is for 3D support with a very concise representation compared to that of html5 and silverlight. Now, adobe really has done it. Adobe alchemy allows conversion of c/c++ code into low level actionscript bytecode. Secure execution at native speed. Full GDB support, compiles with gcc, supports all the tricks c++ has in its sleeve. Just insane. The bytecode is now running at 40% native, wiht high hopes to get it to 80% native speed before alchemy is launched. You also get finally direct access to converted c++ libraries from AS code. All existing code assets are finally browser compatible.

If you are interested in where online gaming is heading in the future, look no further.

As a demonstration, Epic has converted the >1MLoc unreal engine with alchemy. Watch this whether you are or are not not a coder.


If you are a coder, you need to reserve 45 minutes and watch the video. I am serious. You *have* to watch it.


This is bliss. Triple-a -level games coming to facebook ;). Then push button conversion to adobe air application for your favorite i or android device. I wonder how this will work for windows phone in the future.

In November 2011, we opened a public Bugzilla to interact with the N9 user community and receive end user bug reports and enhancement requests. To this date, we have received over 1100 bug reports. We thank you for the active contribution.

At this point of the product lifecycle, we have identified the major issues to be addressed in the upcoming software updates beyond the PR1.2 release. While we will continue to address issues already reported, we are unable to accept any new requests in Bugzilla.

The Harmattan Bugzilla will remain as read only for some time. However, we will continue to process the bug reports already in Bugzilla.

We kindly request you to continue further Harmattan developer discussions, bugs and other topics under developer.nokia.com. We hope to receive your continued support and help us further improve the quality of N9 software.

A few weeks ago, geocaching.com once again changed their website. The new site features a new map. Unfortunately, the new map doesn't fit well into AGTL. I fixed the bug, however, was not able to finish the N900 version yet, because I don't own an N900 since mine broke last year. I'm currently searching for a defect N900 to buy it for development, you can also speed things up with donations for a used N900.

Update: Rob Kouwenberg ( @cow_n_berg) will send me his spare N900, so the quest for a new old N900 has found a quick end. Geocaching user juleodop send me 60 euro via PayPal, thanks for that!

However, in the meantime you can try this dirty fix. It doesn't affect the installed version of AGTL. Run the following commands in the terminal. # First, install git and python-lxml (as root)
apt-get install git-core python-lxml
# Now, check out the latest version of AGTL (***NOT*** as root!)
git clone git://github.com/webhamster/advancedcaching.git
# Now, run it (also ***NOT*** as root!)
cd advancedcaching/files/advancedcaching
python core.py --hildon

This is untested, so please provide feedback if everything works.

Please be warned, that the new downloading algorithm always fetches the whole descriptions, thus it is much slower than before!

And if you have a partially defect N900 at home, please mail me!

A few weeks ago, geocaching.com once again changed their website. The new site features a new map. Unfortunately, the new map doesn't fit well into AGTL. I fixed the bug, however, was not able to finish the N900 version yet, because I don't own an N900 since mine broke last year. I'm currently searching for a defect N900 to buy it for development, you can also speed things up with donations for a used N900. Update: Rob Kouwenberg ( @cow_n_berg) will send me his spare N900, so the quest for a ...

A Quick Look at Extras in Bugzilla
2012-03-05 through 2012-03-11

I had a server app that had both a desktop and web interface. Though I discovered that the web interface was less than monkey finger friendly on the n9 and required some authentication each time. I thought this was a job for QML and javascript on the device. The good news is that I now have a client using just those tools, so no cross compilation needed at all ;)

The core of the UI is updated via a timer which runs an ajax call, parses the JSON response and gives that to updateModel(). The first implementation of the later method was to clear the listModel and repopulate from scratch each time. Rather wasteful, even though it was only being called once every 2-3 seconds, it was eating up 8-9% CPU of the n9 in top. A better solution is to iterate the existing items, performing update, remove, or add as you go. This needs a "key" field for each tuple and a stable total order on the model JSON data, either from the server or through an explicit client side sort.

I'll probably put this up on github soon, but in the meantime, this is the updateModel() which has the smarts I mentioned above. It takes 3-4% of CPU instead, and should maintain view state better on the device. I use objid as the key, and the "state" is cloned to objstate because I noticed some issues there with QML interaction using state as the property. Interesting what one can do with QML+JS in very short time for the n9.

    function updateModel( model, data ) 
    {
 var existingIndex = 0;
 var existingIndexMax = model.count;
 var id;

 for( id in data ) 
 {
     var found = false;
     var name  = data[ id ];
     var col   = data[ id ];
     var k;
     var row = {};
     row[ "objid" ] = id;
     row[ "name" ] = "v";
     for( k in col ) 
     {
  if( k == "state" ) {
      row[ "objstate" ] = col[k];
  }
  else {
      row[ k ] = col[ k ];
  }
     }

      // find it if it exists...
     for( ; existingIndex < existingIndexMax; ++existingIndex )
     {
  if( model.get( existingIndex ).objid == id )
  {
      found = true;
       model.set( existingIndex, row );
      ++existingIndex;
      break;
  }
  else
  {
      // This element from the local model no longer exists on the server,
      // remove it. Do not advance the index as we have removed an element instead.
      model.remove( existingIndex );
      --existingIndex;
  }
     }

     // it didn't exist, add it as new.
     if( !found )
     {
  model.append( row );
     }
 }
    }

Front Page

Dual-booting the Mer-based Nemo Mobile on Nokia N950

Instructions for dual-booting Nemo Mobile on the N950 are available at the Mer Project wiki. The process involves extracting and flashing a specially modified file onto the device. The process is reversable and doesn't seem like it should affect your Harmattan install (although backing up is obviously recommended before you start the process). "It is simple enough really. Turn the phone on like normal, be prompted with a few warnings and a standby screen featuring green text. Now, to boot into Harmattan, press the Volume Up button, to boot the Alternate OS, press the Volume Down button."

Read more (wiki.merproject.org)
Read more (mynokiablog.com)

In this edition (Download)...

1. Front Page
   • Dual-booting the Mer-based Nemo Mobile on Nokia N950
2. Applications
   • Flash Player for Firefox for N9 now available in Nokia Store
   • Review of Firewall+ Pro, a call and SMS blocker for the N9
   • Twitter petition for Skype video call on top of audio calls on N9
   • Qeddit - a Reddit client for Symbian and MeeGo
3. Development
   • Inception provides user access to all Harmattan Aegis permissions
   • Remote text input using Maliit
   • PySide becomes a Qt add-on
   • Embedding microb browser in your N900 app
4. Devices
   • Reuters adds to rumours Nokia Meltemi
   • Harmattan Bugzilla closed for new bugs
   • Decrypting N900 backups without a device
5. Announcements
   • Mahjong Solitaire for N9
   • Alpha release of KhtSimpleText text editor should be available soon

I recently ran into this problem and could not find any good solution on the Internet. So next comes a small summary of the problem with hopefully enough buzzwords, so Google can lead you here.

If you want to do C++ development on Android, you need the NDK for cross compilation. It comes by default with its own build system called ndk-build, which basically is a bunch of custom makefiles. But if you are sharing code between the Android Platform and lets say plain Linux, you have likely already a build system installed. For C/C++ CMake is quite popular as it supports different platforms and compilers. Fortunately there is already a project which adds Android support to CMake. I will not cover that – instead I assume you are using it already.

Unfortunately you cant use the ndk-gdb script supplied with the NDK to debug your application as it relies on the behaviour of ndk-build. But as said earlier, ndk-build is no wizardy, but just a bunch of scripts. So it is possible to emulate the behaviour using CMake, as following:

Add the following macro to your CMakeLists.txt file

macro(ndk_gdb_debuggable TARGET_NAME)
    get_property(TARGET_LOCATION TARGET ${TARGET_NAME} PROPERTY LOCATION)
    
    # create custom target that depends on the real target so it gets executed afterwards
    add_custom_target(NDK_GDB ALL) 
    add_dependencies(NDK_GDB ${TARGET_NAME})
    
    set(GDB_SOLIB_PATH ${PROJECT_SOURCE_DIR}/obj/local/${ANDROID_NDK_ABI_NAME}/)
    
    # 1. generate essential Android Makefiles
    file(WRITE ${PROJECT_SOURCE_DIR}/jni/Android.mk "APP_ABI := ${ANDROID_NDK_ABI_NAME}\n")
    file(WRITE ${PROJECT_SOURCE_DIR}/jni/Application.mk "APP_ABI := ${ANDROID_NDK_ABI_NAME}\n")

    # 2. generate gdb.setup
    get_directory_property(PROJECT_INCLUDES DIRECTORY ${PROJECT_SOURCE_DIR} INCLUDE_DIRECTORIES)
    string(REGEX REPLACE ";" " " PROJECT_INCLUDES "${PROJECT_INCLUDES}")
    file(WRITE ${PROJECT_SOURCE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/gdb.setup "set solib-search-path ${GDB_SOLIB_PATH}\n")
    file(APPEND ${PROJECT_SOURCE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/gdb.setup "directory ${PROJECT_INCLUDES}\n")

    # 3. copy gdbserver executable
    file(COPY ${ANDROID_NDK}/prebuilt/android-arm/gdbserver/gdbserver DESTINATION ${PROJECT_SOURCE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/)

    # 4. copy lib to obj
    add_custom_command(TARGET NDK_GDB POST_BUILD COMMAND mkdir -p ${GDB_SOLIB_PATH})
    add_custom_command(TARGET NDK_GDB POST_BUILD COMMAND cp ${TARGET_LOCATION} ${GDB_SOLIB_PATH})

    # 5. strip symbols
    add_custom_command(TARGET NDK_GDB POST_BUILD COMMAND ${CMAKE_STRIP} ${TARGET_LOCATION})
endmacro()

Then use it like

add_library(YourTarget ...)
ndk_gdb_debuggable(YourTarget)

You should now be able to use ndk-gdb with CMake, just as if you would have used ndk-build.

Note that steps 4 and 5 are optional for debugging. They just reduce the size of the library that has to be transferred to the device. If you dont care, you can just leave them out. But then the solib search path from step 2 must be set to:

file(WRITE ./libs/${ANDROID_NDK_ABI_NAME}/gdb.setup "set solib-search-path ./libs/${ANDROID_NDK_ABI_NAME}\n")

Ideally someone should integrate that in the Android toolchain linked above.

Update Merged Upstream

The Nokia N9 UX Guidelines site is now up to date, so go have a look. We've also improved the organisation of the site to serve UI designers and developers better. Improved linking between the UX site and the developer documentation means that it's easier to match what you want to do with how to do it.

However, the Chinese-language UX materials have not been updated at this point. If you are using them, we'd like to hear from you! Do you think it's useful having some material available in Chinese? Should there be more? Less? Different materials?

We have released updates for both software development kits.

The Harmattan target for the Qt SDK can now be updated online, using the SDK maintenance tool. The additional functionalities concern mostly improved runtimes for testing. The Qt Quick Components in the Simulator have been upgraded to the same version as is used on the device, and the Simulator now supports both landscape and portrait orientations. Also, there are now three separate QEMU images - one for PR1.0, 1.1 and 1.2 each. The full release notes are available in harmattan-dev.

The Platform SDK is no longer tagged beta, though some usability issues remain, as described in the release notes.

The API baseline remains at PR1.0 (to ensure that all users can safely obtain and use the applications), but a few additional interfaces are now available as extensions: Frankencamera is supported in all Harmattan releases, Simple NDEF Exchange Protocol is supported only in PR1.2. The development packages containing the additional interfaces are available for download.

This Developer Library and API reference update includes documentation for PR 1.2 features and documentation enhancements for existing features:

• Information on the new Instrumentation Dashboard, and how to use strace, latrace, swaplogger and mem-cpu-monitor with it.
• New section on Multimedia APIs which brings together the documentation of all multimedia-related functionality.
• New UX related materials: Gestures, Themes, Using Bottom Toolbar, Non-visual feedback and Using Shaders.
• New items on the List of path name exceptions.
• New section on Integrating account management to applications.

As always, your feedback about the Developer Library is very welcome!

 

 

We have published a new example application for Harmattan developers.

The application's source code is available on harmattan-dev. It can be built in Qt SDK using the enclosed project-file.

The application features several key elements in the Harmattan application programming interface, and thus provides a good starting point for learning about specific technologies and application development for N9 in general.

The initial version of the showcase application concentrates on Qt Mobility interfaces (ranging from maps, multimedia and messaging to visualizing the sensor data with a compass overlaid on camera input).

In the messaging area it provides insight how NFC is easily integrated into an application.

Feedback on the application are best given as comments in this blog entry.

As part of my foray into n9 apps, a new one that displays information from the Australian Bureau of Meteorology on the n9. Being pure QML + Javascript it also runs on the desktop. The forecasts include min and max temps, and for the Europeans reading this, the middle line "10..." is the UV prediction and roasting window for the day... all your sunscreen are belong to us.



Apart from saving a little on downloads for the topology and background images when on the move, you get to customize those as they are just png files living in the images subdirectory. So I have the local rocket launch site indicated. I'd like to make a LOTR style topology overlay, perhaps mt Glorious becomes Mordor?

Code available at https://github.com/monkeyiq/qmlbom

In last weeks, I’ve been taking a look at the web applications standards support in Epiphany, as part of my work at Igalia. Xan wrote about the Save as web application feature present in Epiphany 3.2, that is a base for very simple (and userful) web applications support in Gnome desktop.

To continue with this work, I’ve been investigating on adding support for some web app stores. So I’ve done an experimental implementation for Mozilla Open Web Apps (as in 2011 tech preview), Chrome Web Store hosted and packaged apps, and Chrome CRX-less apps.

Screencast using Chrome Web Store.

This is an experiment. Not supported, and it may actually stay out of official Epiphany. So there are lots of things not working at all. This is first a way to have a big number of apps to play with our application mode, and improve it. So no permissions check, URL’s match may be broken, many apps will fail to even log in… Did I say it is an experiment? Most obvious issues are related with this external links handling bug.

But, if you just want to play with it, just try my branch webapp in my Epiphany Github repository. By default, support is disabled, so you’ll have to enable these keys:

$ gsettings set org.gnome.Epiphany.web enable-chrome-apps true
$ gsettings set org.gnome.Epiphany.web enable-open-web-apps true


You can try with Mozilla Labs Apps Dir from 2011 tech preview and Chrome Web Store.

Openismus has recently had to let some great developers, and good friends, go. We are now much smaller.

It's time for the next Maemo election.  Any community member who has karma of 100 or more may be nominated for Council or may nominate themselves via the maemo community mailing list (nominations must also be accepted on the mailing list).  The nomination period will close on Saturday, 31 March.

The voting is preliminarily scheduled to run from Thursday, 5 April, to Wednesday, 11 April.  If there are less than four nominees, then they will be considered to be the consensus choice of the community in the election and no vote will be necessary.

Each member of maemo.org, who has an account that is more than 3 months old and who has earned over 10 karma points on that account, gets an electronic ballot.  The election is a "single transferrable vote."  They rank their Council candidates in order of preference; if their top candidate cannot get elected with the votes they receive, the votes are redistributed until all council seats have been allocated.

 

Please give consideration to nominating people you trust with the future of maemo.  Nokia will stop future funding for maemo.org and cannot commit to handing over or licensing the website or parts of the infrastructure to the community.  The current council has concluded that reorganizing maemo.org is not feasible and has started looking into a Plan B.  There have also been proposals to bring Harmattan into maemo.org, and to coordinate with other similar projects such as WebOS, Qt or Nemo.  It is preferable that the future of maemo be made by a deliberate decision of the community.  Please help that happen by nominating and voting in the election.

A Quick Look at Extras in Bugzilla
2012-03-12 through 2012-03-18

I seem to have not blogged about this, but Open Advice, our book on Free and Open Source Software: what we wish we had known when we started, was published last month.

The book was edited by Lydia Pintscher and includes essays from 42 authors, many of whom you'll recognize if you tend to go to FOSS conferences. The LWN book review concludes:

Open Advice is a book that will be helpful to those who are new to FOSS, but, because of the individual voices, styles, and tones, it doesn't read like a "how to". It could even be recommended to those who aren't necessarily interested in contributing, but are curious about what this "free software thing" is all about. It is, in short, a great book for a variety of audiences and the (mostly) two or three page essays make it easy to read, while the anecdotes and recollections personalize it. The authors, editor, and everyone else who helped should be very pleased with the result. Readers will be too.

I probably shouldn't give the ending away, but my essay on cross-project collaboration, a subject I've also blogged about, ends with:

Good luck with breaking down the project boundaries! In most cases it works if your ideas are good and presented with an open mind. But even if you do not find a common ground, as long as your implementation solves the use case for you it has not been in vain. After all, delivering software, and delivering great user experience is what counts.

The book is licensed under CC-BY-SA, and is available as free download in ePub, mobi and PDF formats, and as paperback from Lulu. The book sources are available on GitHub, patches welcome!

Front Page

Time for the election of the next Maemo Community Council

RM Bauer has announced the start of the spring 2012 election for the Maemo Community Council. Six months ago, only three candidates stood and so were selected without a vote. RM Bauer has been the most visible member, with Momcilo Majic and Jeremiah Foster being mostly quiet. This term has seen the growth of the Harmattan community, and the death of MeeGo - which has led some, including Nokia's Matti Airas to ask if the future of the Harmattan community lies within its maemo.org roots. Rob's announcement says:

"Please give consideration to nominating people you trust with the future of maemo. Nokia will stop future funding for maemo.org and cannot commit to handing over or licensing the website or parts of the infrastructure to the community. The current council has concluded that reorganizing maemo.org is not feasible and has started looking into a Plan B. There have also been proposals to bring Harmattan into maemo.org, and to coordinate with other similar projects such as WebOS, Qt or Nemo. It is preferable that the future of maemo be made by a deliberate decision of the community. Please help that happen by nominating and voting in the election."

Anyone can put forward a community member by posting to the maemo-community list, although they must accept the nomination to be a candidate. Similarly, people can put themselves forward directly - which has historically been the main mechanism.

Read more (maemo.org)

In this edition (Download)...

1. Front Page
   • Time for the election of the next Maemo Community Council
2. Applications
   • NFC friending in Facebook for N9 https://t.co/kMOPRUA7
   • Fixing AGTL geocaching tool on N900
3. Development
   • MeeCast for Tizen
   • Qt SDK Harmattan tooling updates
   • UX guidelines documentation for Nokia N9 updated to latest standards
   • Differential updates in QML models
4. Devices
   • Nokia N900 charging an N9 via USB host mode
5. Announcements
   • Metro theme for Harmattan

With 5.0 now being feature frozen, I thought I'd turn myself towards something I've been meaning to do (and talking about doing) for a very long time. Back before the Qt Project launched, even before Qt Contributors Summit 2011, in fact. I thought I'd make QFileSystemWatcher more useful.

Some days ago I was writing about how to have mixed QML/C++ objects in a QML application for Igalia, but I faced a problem with the code that I had written. And the problem was that I needed to receive some events and from the QML elements I was loading. Retaking that code:

#define QML_PATH "/path/to/the/qml/files/"

MyObject::MyObject(QDeclarativeItem *parent = 0) :
    QDeclarativeItem(parent)
{
    QDeclarativeEngine engine;
    QDeclarativeComponent component(&engine,
        QUrl::fromLocalFile(QML_PATH "MyObject.qml"));
    QDeclarativeItem *rect =
        dynamic_cast(component.create());
    rect->setParentItem(this);
}

and being MyObject.qml something like:

Button {
    id: "myButton"
    text: "Do something cool"
}

The natural way of connecting that button to some slot you are writing would be something like:

MyObject::MyObject(QDeclarativeItem *parent = 0) :
    QDeclarativeItem(parent)
{
    QDeclarativeEngine engine;
    QDeclarativeComponent component(&engine,
        QUrl::fromLocalFile(QML_PATH "MyObject.qml"));
    QDeclarativeItem *item =
        dynamic_cast(component.create());
    item->setParentItem(this);
    connect(item, SIGNAL(clicked()), this, SLOT(doCoolStuff()));
}

Even if you do this, you are not getting any event in the QML button you declare. It behaves as it were a label or whatever, but the key is the engine. The engine must live while you need the events of the QML component. And the easiest way of getting that done is adding the engine as a private class attribute:

#ifndef MYOBJECT_H
#define MYOBJECT_H

#include 
#include 
#include 

class PostCapture : public QDeclarativeItem
{
    Q_OBJECT

// ...

 private slots:
    void doCoolStuff();

 private:
    QDeclarativeEngine m_engine;
};
#endif

and of course removing the engine stack declaration from the constructor:

MyObject::MyObject(QDeclarativeItem *parent = 0) :
    QDeclarativeItem(parent)
{
    QDeclarativeComponent component(&m_engine,
        QUrl::fromLocalFile(QML_PATH "MyObject.qml"));
    QDeclarativeItem *item =
        dynamic_cast(component.create());
    item->setParentItem(this);
    connect(item, SIGNAL(clicked()), this, SLOT(doCoolStuff()));
}

Voilà.

Of course, if you need to connect to any element that is not the root element, you can always forward the signals and properties from the QML root object or just use the QObject::findChild method to access the right component.

Xournal for the N800 and N810

Smoke the Bugs is now available to download from Nokia Store for Harmattan N9 and for Anna/Belle. No bugs (except software bugs!) were harmed while developing the game, but to know whether this virtual bug smoking is suitable for you, check this video of game play on N9:



As explained here earlier, this was partly an expedition on making a game with pure QML + JavaScript + shader effects. Plan was to make it totally without C++ (excluding the launcher which Qt SDK generates automatically) and to see what the outcome would be.

So summing up some random development notes here:

• Harmattan version of the game utilizes Qt-components for portrait main window and for disabling swipe while playing. Symbian version does not use Qt-components as pure QML was enough.


• It's good to use Loader for separating rest of the UI from initial "splash screen" for faster startup. Another option on Harmattan would be to show static splash screen image with invoker.


• In this game, loaders are also used for help and high score views. As these are not often used, it is better to save memory and only load them when needed. Loading is fast enough not to cause notable delay.


• ShaderEffectItem is available on Harmattan, Belle and Anna+Qt 4.7.4, so it's possible to target quite a many devices. Exception is Nokia 500 which is lacking GPU for OpenGL.


• With Symbian, setting QGLWidget for viewport is required to be able to use ShaderEffectItem. On Harmattan this is not needed as the default graphics system is already set to use OpenGL.


• When application is minimized, unload ShaderEffectItems or set their 'visible' property to false. Not doing this causes minimized application to use resources unnecessarily. Application state can be tracked with Qt.application.active


• When writing shaders, be careful to keep them performing well. Symbian devices and especially newer Belle ones can handle heavy fragment shaders better than N9. As an example, moving night effect math from fragment shader to vertex shader improved performance notably on N9.


• Avoid too many ShaderEffectItems to save resources. As an example, instead of each bug containing its own burning effect, there are three global effect items in a queue, positioned and animated when needed. If three simultaneously burning bugs are not enough, it's easy to add more effect items into queue.


• QML performance notes give good general guidelines what to avoid. Qt5 version of this document is even better and provides also information on how Qt5 scenegraph and V8 engine changes reflect to optimizing QML performance.

P.S. I joined Nokia ~month ago which may increase my bias towards Qt... But it's not like I wouldn't have made my opinion pretty clear already ;-)

As you know (and it's already reported), there's currently no way to import an OPML into the Nokia N9 Feed Reader application (see Harmattan Bug #159).

However, I noticed that when you open a feed link with the built-in browser, it launches the Feed Reader app, and asks you to subscribe to the feed. I guessed that it was communicating with the Feed Reader using D-Bus, so I dbus-monitored it, and that's what I found:

1. First, the browser asks the application to subscribe to a given feed (here I'm asking the client to subscribe to my blog's feed):
   

   dbus-send --print-reply --dest=com.nokia.FeedReader \
   / \
   com.nokia.FeedReader.subscribeFeed array:string:"http://simonpena.com/blog/feed/"

2. If the user accepts that, then the Feed Reader application requests the Engine to actually subscribe to the Feed. The nice thing is that, although you cannot (AFAIK) ask the client to subscribe to more than one feed at the time, you can ask the Engine to do it, so this actually works (requesting the engine to subscribe to my blog, Planet Maemo and Planet Igalia):
   

   dbus-send --print-reply --dest=com.nokia.FeedEngine \
   / \
   com.nokia.FeedEngine.subscribe \
   array:string:"http://simonpena.com/blog/feed/","http://maemo.org/news/planet-maemo/rss.xml","http://planet.igalia.com/atom.xml" \
   string:"rssatom"

From this point on, it should be quite straight forward to import an OPML into the Feed Reader application. You can use a QDomDocument to parse the OPML or use QML's XmlListModel to parse the OPML file.

XmlListModel {
    property string subTitle: ''

    query: subTitle ? "/opml/body/outline[@title='" + titleText + "']/outline": "/opml/body/outline"

    XmlRole { name: 'text'; query: '@text/string()' }
    XmlRole { name: 'title'; query: '@title/string()' }
    XmlRole { name: 'type'; query: '@type/string()' }
    XmlRole { name: 'xmlUrl'; query: '@xmlUrl/string()' }
    XmlRole { name: 'htmlUrl'; query: '@htmlUrl/string()' }
}

Then, you can use this to subscribe to the feeds using D-Bus:

static const QString DBUS_IFACE("com.nokia.FeedEngine");

void Controller::subscribeFeeds(const QStringList &feedList) const
{
    QDBusInterface dbusInterface(DBUS_IFACE,
                                 "/",
                                 DBUS_IFACE,
                                 QDBusConnection::sessionBus());

    dbusInterface.asyncCall("subscribe",
                            QVariant::fromValue(feedList),
                            QVariant::fromValue(QString("rssatom")));
}

I hope you find this useful

I've been meaning to write about this for a while, but I've only just now been driven over the edge by having to go and basically run sed over code again for no good reason.

Continuing my n9 apps I now have an index search app that uses libferris. Currently I have only exposed URL regular expression search. This is searching an index maintained and stored in a PostgreSQL database. Solving regex query in a timely manner is a fairly complex problem with one useful solution outlined in one of my previous blog entries.

Note that data is downloaded over normal http(s) from the server using the n9 app, so no NFS or other network mounts are needed. This might be handy for grabbing a PDF, image or text file off an Intranet file server while on the move.



I have also been updating the clucene libferris module to allow more effective index use during regex/infix queries. This libferris engine works quite nicely on older ARM machines. Benchmarks on that to follow, once I reindex the arm and produce the comparative figures.

Firefox for Mobile Device Proximity - http://dougturner.wordpress.com/2012... March 22, 2012 from DougT » mozilla - Comment - Like

As part of my work at Igalia I am writing an app to record some videos for the Nokia N9. I wanted to get them shown in the gallery so I tried the DBUS approach, that is something similar to what is explained here. The problem is the same they faced, meaning that I got gallery in foreground when it was not previously running, but not otherwise.

The solution to that was using libcontentaction. In order to get this working, first you need to get the vendor name in the tags of your pictures or videos, otherwise Tracker will not index them correctly and this solution can be useless.

With the following solution Gallery will be brought to foreground and show the desired file. Code would be something like:

using ContentAction::Action;

[...]

{
    Action action =
        Action::defaultActionForFile(uri,
            "x-maemo-nepomuk/device-captured-video");
    if (action.isValid()) {
        qDebug() < < Q_FUNC_INFO << "chosen action:" << action.name();
        action.triggerAndWait();
    } else {
        qWarning() << "could not file action for" << m_file;
    }
}

The mime type is one of the defined in the galleryserviceaction.desktop that you can find in the device. For images, you can also check the mime types in that file and maybe you do not need to specify it, but I have not tried this and let it to you. Please, comment me your findings.

The n9 libferris app now allows you to search by the URL of the file as before, but also now by the file text content and it's modification time. Query type is selected by a button in the top right corner which unfortunately isn't nearly as easy to read in the video file as it is in real life.

As libferris handles extraction, update, and storage of metadata from disparate locations I have also added a sprinkling of what that means into the video. Notice that the first search by URL shows a comment "REST interface to libferris" in bold. This is simply the "annotation" metadata of the file but is much more interesting to the searcher than it's URL. Likewise in the second query, which finds a Gutenburg text file by searhing on text content, the annotation offers the name of the book that the file contains. Again much more interesting content to the human who is at the helm.

The third query is on the modification time of the files. There are three ways offered to perform a time search, "more recently than this" or "than last" which can have month or day as options for example, and modified >= X months ago which obviously wants a number as the query text. When querying by time like this, libferris happily accepts some human readable terms like "begin this month" as the time you specify. This makes it just as convenient to use search in scripts as in the dedicated front ends like the n9 app.



The plan is as always, to push metadata from being an after thought to being a first class citizen: able to be created, read, written, indexed, and searched on. Any file with metadata should be able to expose that as simply as its mtime or size, which is all currently done via a key-value "Extended Attribute" interface at the lowest level.

If you like libferris or the recent updates (status.net mounting, these indexing tweaks etc) then please consider making a donation. If you want to use this technology at a corporate level, please feel free to contact me.

Nearly two years ago (in April 2010), I ported Brain Party to the N900 using javispedro's awesome SDL_gles library. Having nearly forgotten about it, I "ported" it to Harmattan today - It's even a bit easier with Harmattan's SDL, which includes the necessary changes. The game doesn't pause/silence when put into the background, but the basic functionalities work, including sound.


Download here: brainparty_0.5.91-3_armel.deb (39 MB)
Source here: brainparty_0.5.91-3.dsc / brainparty_0.5.91-3.tar.gz

The game itself has been written by Hudzilla Games, who also published the game for the iPhone and XBox 360 - if you like the game, you can support them by buying the game from there. This port is based on the open source version of the game.

It’s been a long while since I was doing any personal coding projects and even longer since the last time I gave much thought to the development environment and tools that I would use. However, that time is upon me again, I’ve had an idea for an app I’d like to develop for android. Last time I developed anything it was for maemo, for the n900. Then it was a twitter client I called ‘witter’, and I developed it mainly as an educational thing, a modern day ‘hello world’. I figured it contained just the right mix of UI, and backend services integration to make for an interesting project. As it turned out, there really weren’t many twitter options on maemo at the time, and so I got quite a lot of interest from the community in what I was developing.

A Quick Look at Extras in Bugzilla
2012-03-19 through 2012-03-25

Front Page

Android ICS (Ice Cream Sandwich) gets alpha release for Nokia N9

allboutn9 summarises the progress made so far on getting Android running on the N9: "Those who don't want to be limited to MeeGo might soon have a very well running port of Android ICS ("Ice Cream Sandwich") called NITDroid which allows to use two systems on the N9 with dual-boot."

"NitDroid might always remain a project which is rather dedicated to experimental users. But it's very impressive to see what the N9 is able to do and why not having two platforms on one phone than buying two different devices? The recent Alpha-version shows that the port was successful. Many drivers for the N9 were found and basic tasks are already possible."

Read more (allboutn9.info)

In this edition (Download)...

1. Front Page
   • Android ICS (Ice Cream Sandwich) gets alpha release for Nokia N9
2. Applications
   • Extraplugins for additional IM accounts on N9 removed from Nokia Store
   • Importing OPML files into N9 feed reader
   • Another review for Firewall+ - a call & SMS blocker for N9
3. Announcements
   • Smoke the Bugs game in pure QML in Nokia Store for N9 and Symbian

Firefox for Mobile Device Light Sensor - http://dougturner.wordpress.com/2012... March 26, 2012 from DougT » mozilla - Comment - Like

GNOME 3.4 is around the corner, and with it a new version of its little web browser that could. This is for sure one of the most action packed releases in a long time, so let’s do a recap of the last 6 months of development.

My growing collection of Qt/QML applications has now hit 6 apps with the inclusion of a Zoneminder client for the n9. As I still have ideas for more apps I wonder how long until I fill half a screen with my own apps on the device ;)



Anyways, the Zoneminder app uses server side scaling and jpeg generation to keep bandwidth down and CPU/RAM very low on the device. I have modified some of the images for example purposes. The app is basically as shown but will display your real camera data instead of Koalas... Unless you are lucky enough to have some furry little friends. The first camera starts a live view right off the bat when the app starts, so there is as little finger use needed to get some useful action from running the app.

Only active cameras are listed. The play button changes the image on the right to be a 1 second rolling "live view" of that camera. The little watch moves to the recorded events for that camera which is shown below. The config is quite simple; the Zoneminder server URL, and the user/password to login to that server.



Alarm events are shown on the left side and the play button rolls through that event with the progress bar showing how far through the alarm you are. Naturally both the lists scroll to show more cameras or events if there are more than 5. By default only 25 of the most recent alarm events are shown in the list. A future expansion might allow paging back to see older ones.

The Nokia N9 firmware upgrade rate has been rapid. Now is the time for developers to move their own application testing and verification from Harmattan PR 1.0 to Harmattan PR 1.1.

The original Harmattan software release (PR 1.0) is now in an ever-diminishing minority. Harmattan PR 1.1, the first update release (introduced on week 45) took over the installed base in less than two months. Now four weeks old Harmattan PR 1.2 release has continued in the same groove, or even faster.

Hence, we have initiated steps to change the principal test environment from Harmattan PR 1.0 to Harmattan PR 1.1 in the Nokia Store. If your application previously has been rejected on account of PR1.0-incompatibility, those issues are now automatically waived.

The SDK and corresponding sysroot in the Harmattan target is not (yet) updated from PR 1.0. In other words, you will still compile against Harmattan PR 1.0 sysroot for time being. Availability of a newer sysroot and instructions on how to take it into use will be announced at an appropriate time.

And if you have already updated your device to PR1.2, you can utilize the remote device access functionality or one of the multiple QEMU variants (now available with the update to the Harmattan target) to pre-verify your application's correct behavior.

A new version of gPodder has been released, and the package is already available from Nokia Store here, and waiting for your QA feedback in Apps For MeeGo here. This works for both N950 and N9 users. To get access to Apps For MeeGo, go to http://apps.formeego.org/ on your device, and install the Client from there.

The new gPodder version comes with some improvements for Harmattan users:

• Redesigned artwork for the main window and episode list
• Better arrangement of podcast list and cover artwork there
• New preferences menu, containing gpodder.net and orientation settings
• New empty state UI for first-time users
• Various other changes to be more in line with the UX Guidelines
• Context menu item to delete episodes without downloading them

I hope you enjoy this new release - please report any issues you find or ideas you have at http://bugs.gpodder.org/ - and don't forget to QA the package in Apps For MeeGo.

This is a feature that I personally wanted for a long time. Interrupted by FOSDEM, some Wayland research and many other things, I finally managed to get word prediction and error correction beyond prototype quality. The video shows just how amazingly good the Presage word prediction can be, even without extensive training (in fact, for the video we used the minimal language model training that comes with a regular Presage installation). The second part of the video shows how combining Presage with a spellchecker such as Hunspell further improves the provided word candidates.

Presage uses a very scalable approach called text n-grams. There is a lot of research in that area, but language models of contemporary language usage are either well guarded or cannot be freely distributed. Luckily, Presage comes with training tools such as text2ngram. Users can feed arbitrary language corpora to it, though one should be careful to perhaps not mix different languages too much.

Matteo Vescovi, the author of Presage (formerly known as Soothsayer), started the work as part of his master thesis a couple of years ago. The heart of Presage are the different predictors. They can be queried in parallel and the result lists are merged, using probability analysis.

Presage certainly has a lot of potential. It comes with an easy to use C++ API but also provides bindings for C and Python. In fact, it even provides a D-Bus API, which would make it possible to run it as a system service. The user could then benefit from (and train!) the same language models from different applications.

Hunspell probably doesn’t need much introduction. It is used in many Linux desktops. It’s a fine library and comes with many dictionaries. However, one should be aware that Hunspell itself cannot provide word prediction, which is why it wasn’t enough for mobile text input. As a fallback for Presage, it works very well though.

Of course there are a couple of things we could do from here. As Jon mentioned in the video, the virtual keyboard’s word ribbon UI could host word suggestions from other applications, such as the Google search in the browser. For Unity’s dasher input or Gnome Shell’s search, the application names could be shown instead. Or we could hook it up to Bash completion.

PS: Anyone up to package Presage for Fremantle or Nemo? It could be pretty interesting to see the next release of Maliit running on the N900.

Permalink | Leave a comment  »

Due to a major change in the geocaching.com website, AGTL became unusable a few weeks ago. Today, I present version 0.9.0.0, which fixes this problem.

Downloading the geocaching overview became a bit slower, because AGTL now needs to download more data to get the geocache positions right. Together with the map overview, all data except logs, images and waypoints of the geocaches are downloaded. While it now takes longer to see what geocaches are around you, the filter and sort feature is more useful than before (because more data is available).

This version runs on the N9 and N900 thanks to Rob Kouwenberg, who sent me his spare N900. The next versions will all be released for the N900 at the same time as for the N9.

This is to be considered as a BETA version, i.e., it will contain bugs. However, I can't comprehensively test both versions on my own, so please file any bugs here! Really, that's the fastest way to get them fixed!

I'm also looking for a designer who is willing to design a new logo for the app.

Now get the N900 version (also available in extras-devel) or the N9 version and start heavy testing!

As always, your donations via PayPal are welcome.

Update: How to send me debug logs?

Debug logs can now be send by the application itself. All you need is your mobile device with a working internet connection and a terminal command. On the N9, open up a terminal and enter agtl-meego --remote On the N900, open up a terminal and enter /opt/advancedcaching/core.py --hildon --remote The application should now start (except if it has a bug in the startup phase, that is). You can file a bug report, send me an e-mail or write me on twitter. What I need is the IP address of the device (yours is currently 213.128.137.20) and the date on which you've created the debug log.

Update 2: If the application doesn't start at all, try moving the file .agtl/caches.db to .agtl/caches.db.old using the following command in the terminal mv .agtl/caches.db .agtl/caches.db.old I hope to fix this bug for the next version.

Update 3: Some early birds had a problem with AGTL not starting on the N9. Please download the file again, I had the wrong .deb in the wrong place. The new file has an md5sum of 78cbea1b32f5200b253bb8218f63d33e.

Due to a major change in the geocaching.com website, AGTL became unusable a few weeks ago. Today, I present version 0.9.0.0, which fixes this problem. Downloading the geocaching overview became a bit slower, because AGTL now needs to download more data to get the geocache positions right. Together with the map overview, all data except logs, images and waypoints of the geocaches are downloaded. While it now takes longer to see what geocaches are around you, the filter and sort feature is more u...

I always tend to lean more towards SSH for VPN stuff than other tools like openvpn. With this mindset I was working out how one might get access to servers on the Intranet while on the move. Having created a bunch of nice little apps that do things on my network is all well and good, but I wanted to also use them while on the move.

My current solution is to use two socks servers on the phone. It might seem strange to need two, but this allows routing depending on source address and destination address. The first SOCKs server is dante which routes all "normal" traffic directly to the chosen Internet connection on the phone. Traffic which wants to go to selected addresses on my Intranet is instead forwarded to a second socks proxy on the phone. This second socks proxy is implemented with ssh "DynamicForward" to send traffic over the SSH link to the Intranet.



The glory here is that Internet traffic goes directly, and Intranet traffic is sent over an encrypted pipe to the Intranet. If on the other hand I connect to any router on the Intranet, the phone gets a local IP address and dante is instructed to "route" traffic from that local address directly to the target instead of to the second local ssh socks server. Thus I don't have to concern myself with the details of which side of firewalls I am on, the phone automatically does that for me and chooses the most efficient route for packets.

Having a phone that runs so much like a proper Linux distro makes this sort of thing fairly easy to get going. No need for funky NDKs, NDAs, or TLAs.

If you want to play around with this stuff I have dante debs in my repo:
http://fuuko.libferris.com/maemo/n9/
Using non privlidged ports on the phone means you can run danted as a normal user. I have an icon on the n9 home screen that makes sure dante is running instead of using init.d at the moment. Also, an icon that runs a bash encapsulated with tsocks can be handy for tinkering:
Desktop file segment:

Exec=meego-terminal -n -e /bin/sh /home/user/bin/create-tsocks-env
...

$ cat /home/user/bin/create-tsocks-env
export http_proxy=http://1.2.3.4:1313/
tsocks bash

Using a similar style Exec in a desktop file one can start the SSH client in "-N" mode and use the passphrase to connect and setup an SSH connection with a socks server on the phone. It is quick and dirty without shiny QML interfaces, but it works^TM.

 

This post is a shameless plug for a new project started in this TMO thread.

The goal is to take advantage of the “USB Host” (h-e-n) package to stream digital audio through the USB port.

In the portable music player scenario, the N900 is used for digital music storage (32BG internal + µSD), user interface software (like Rockbox) and decoding music files (like mp3 or flac) to uncompressed PCM format.

This stream is then sent out through the USB port to an external digital-to-analog converter (DAC) and headphone amplifier, bypassing the N900′s own electronics, to achieve maximum sound quality (see the first post in the thread for a more detailed explanation).

Such DAC/amp “combos” exist in portable form, such as the Fiio E17 and iBasso D-Zero.

Another (technically similar) scenario is to stream sound in through the USB port, for example from a portable mixing console, and use the N900 as a high-quality recording device.

Right now we have proof-of-concept for both use cases, as h-e-n with power-kernel automatically supports such USB audio functions, and the corresponding ALSA device is created.

Using command-line tools in xterm (like mplayer, MOC or arecord), sound can be streamed to/from this ALSA device, with very good results.

One limitation of this method, however, is that it doesn’t work with Hildon GUI apps (like the stock Maemo media player, or the Rockbox port).

Another is that it doesn’t use the N900′s DSP, doing all the encoding/decoding in software, with higher than necessary CPU usage.

Our present understanding, so far, is that we would need to:

• tweak PulseAudio to make the USB “sound card” available system-wide,
• and use gstreamer to take advantage of the mafw framework and the DSP.

 

Unfortunately none of us end users really understand how this alsa/mafw/gstreamer/pulseaudio puzzle fits together inside Maemo. Conventional wisdom for regular desktop Linux does not seem to apply, and all experiments to date have failed.

If you are reading this and are knowledgeable about the specifics of the Maemo sound system… and enjoy a challenge… please do chime in ! :-)