Planet INdT

Great start at Ubuntu Developer Summit (Q or 12.10) for ARM

2012-05-10T08:13:46+00:00

This week I’m proudly participating at the Ubuntu Developer Summit to help planning and defining what will the Quantal Quetzal (12.10) release be in the next following months.

As usual I’m wearing not only the Linaro hat, but also my Ubuntu and Canonical ones, interested and participating actively at most topics that are related with ARM in general.

And what can I say after the first 3 days at UDS-Q? Well, busy as never before and with great opportunities to help getting Ubuntu to rock even more at ARM, with current devices/platforms and with the exciting new ones that will be coming in the next few months.

Here are a few highlights from the first days:

Monday – May 7th

Introduction and Keynote
- Great start as usual by Mark, showing the great opportunities for both Canonical and Ubuntu, describing the new target and use cases, and also showing how important Cloud is now for Ubuntu. After that we had, finally, the announcement of a real hardware availability from Calxeda, proving that ARM server are indeed real! (which is a quite important accomplishment)
Schedule displays all working with our member’s boards
- This was the first time that all the schedule displays available at UDS were all covered by the ARM boards provided by Linaro. This time we got Pandaboard, Origen and also Snowball constantly showing the schedule through all the day. Low power and powerful devices all around
Plans for a minimum filesystem for embedded devices
- Discussion to cover all the possible embedded related use cases for Ubuntu, and trying to understand the real requirements for a minimum filesystem (rootfs) for those devices. While we didn’t decide to generate the smallest-still-apt/dpkg-compatible rootfs for our users (as ubuntu-core is already covering most of the cases), we’ll provide enough tools and documentation on how to easily generate them. At Linaro side the Ubuntu Nano image should probably reflect such suggestions.
Identify impact of the switch to pure live images for ARM platforms
- Here the focus was basically to review and understand if we would really continue providing pre-installed based images instead of just supporting live based ones. Having the images provided only at the SD cards are very useful to make the bootstrap and install quite easy, but it hurts badly the performance. As we’re now getting ARM boards that are very powerful in many ways, the I/O bound shouldn’t limit what the users would be able to get from them. The decision for Quantal is to drop support for the pre-installed images, and provide live based ones at the SD cards (think like the live-sd image as we have with CD on other archs), where the user would install Ubuntu the same way as done with x86, and using USB/Sata based devices as rootfs by default.
OpenStack Deployment on ARM Server
- The focus of this session was basically to better understand what might be the missing pieces for a proper OpenStack support at ARM. Quite a few open questions still, but the missing pkgs enablement, LXC testing and support and KVM for a few platforms will help making sure the support is at least correctly in place. After initial support, continuous test and validation should happen to make sure the ARM platforms keeps well supported over the time (which will be better stressed and tested once MAAS/Juju is also supported properly at ARM).

Tuesday – May 8th

Detail and begin the arm64/aarch64 port in Ubuntu
- Clearly the most important session of the day for ARM. Great discussion on how to prepare and start the ARMv8 port at Ubuntu and Debian, by starting with cross-build support with multiarch and later support with Fast Models and Qemu. A lot is still to be covered once ARM is able to publish the ARMv8 support for Toolchain and Kernel, and session will be reviewed again at Linaro Connect at the end of this month.
Ubuntu Kernel Delta Review
- Usual review of the patches the Ubuntu Kernel team is maintaining at the Ubuntu Kernel tree. At Linaro this is important as we also enable the Ubuntu specific patch-set at the packages provided by the LEB, for proper kernel and user-space support. Luckily this time it seems the delta is really minimum, which should probably also start to be part of Linux Linaro in the following month.
Integrate Linaro hwpacks for ARM with the Ubuntu image build infrastructure
- Usual discussion about trying to avoid replicated work that is strictly related with each ARM board we support at both Ubuntu and Linaro. Decision is to finally sync with the latest flash-kernel available at Debian and try to get the common project/package with the hardware specific bits in place, so it can be used by linaro-image-tools, flash-kernel and debian-cd.

Wednesday – May 9th

MAAS Next Steps
- Session to review and plan what are the next steps for the MAAS project, which is also missing proper ARM support for now. Great discussions on understanding all the requirements, as they will not necessarily match entirely with the usual ARM devices we have at the moment. Here the goal for ARM is to continue improving the PXE support at U-Boot (even with UEFI chainload later), and understanding what might be missing to also have IPMI support (even if not entirely provided by the hardware).
System Compositor
- Great session covering what might be the improvements and development on the graphics side for next release. Goal is to use a system compositor that would be started right at the beginning at the boot, which will then be controlled and used properly once lightdm is up (with X11). This will improve a lot the user experience on normal x86 based desktops, and luckily on ARM we’re also in a quite nice situation with the work done by Linaro helping getting the proper DRM/KMS support for the boards we support, so I hope ARM will be in a great shape here
ARM Server general enhancements (for ARMv7 and perhaps v8)
- At this session we could cover what seems to be the most recurrent and problematically thing at supporting ARM servers, which is the lack of a single and supported boot method and boot loader. UEFI should be able to help on this front soon, but until then the focus will be to keep checking and making sure the current PXE implementation at u-boot works as expected (chainloading UEFI on u-boot is also another possibility Linaro is investigating). There is also the request for IPMI support, which is still unclear in general how it’ll be done generically speaking.
Integration testing for the bootloader
- As Ubuntu is also moving to the direction of continuous validating and testing all important components available, there’s the need for a proper validation of the bootloader, and the effect at the user experience while booting the system. For ARM it’s also a special case, as U-Boot is still the main bootloader used across the boards. Test case descriptions in place, and discussion will probably continue at Linaro Connect as this is also an area where we also want to help validating/testing.
ARM Server Benchmarking and Performance
- Here the Ubuntu Server Team presented how they are benchmarking and checking performance at the server level at x86, and covering what might still be needed to run and validate the ARM boards the same way. For ARM the plan is to run the same test cases on the available scenarios, and also try to get Linaro involved by making sure this is also part of the continuous validation and testing done with LAVA. Another important topic that will probably be extended at Linaro Connect is finding a way to get the power consumption data when running the test cases/benchmarks, so it can be further optimised later on.
Compiz GLES2 Handover
- Last session of the day, trying to find the missing gaps to finally get the OpenGL ES2.0 support merged at the Compiz and Unity upstream branches used by the entire Ubuntu desktop (across all archs). Following work and actions will basically be to fix the remaining and important plugins after merging the changes, and also getting a few test cases to properly validate the support at Ubuntu. Once all done, it should be merged ASAP.

These are just a few topics which I was able to participate. There are a lot of more exciting work coming on, which can all be found at http://summit.ubuntu.com/uds-q/. Remember that you’re still able to participate in a few of them tomorrow and friday, as remote access is provided for all the sessions we have.

I’m sure a lot of more exciting stuff will be discussed for ARM support until the end of this week, and at Linaro Connect, at the end of the month, we’ll be able to review and get our hands dirty as well

Exciting times for ARM!

Big changes!

2012-05-08T15:05:09+00:00

After 5 wonderful years working with passionate and skilled people I am now moving to São Paulo to work at Facebook’s office for Latin America. My official role will be Partner Engineer.

This doesn’t mean that I will go away from KDE, neither from Qt. It just means that I will contribute more on my free time (as it was before Nokia acquired Trolltech) than during working hours.

I am thrilled with this opportunity and I am sure that all of you who know me are also happy with this announcement.

I will be a little bit offline the next days due to my move, but I will be checking emails regularly

Advances in mobile data collection: Nokia Data Gathering 4.04

2012-05-07T21:02:35+00:00

We have been hard at work developing and improving the Nokia Data Gathering solution, and will be launching an exciting new version in May 2012. The Nokia Data Gathering 4.04 (Dazzling Dourado) release will include bug fixes and new features on the Java mobile client, as well as a brand new Nokia Data Gathering server and user interface. We will also be launching the first Windows Phone client of Nokia Data Gathering.

Come discover and try out Nokia Data Gathering 4.04! On 16 May 2012, the Nokia Data Gathering team will be at Seton Hall University to tell you all about the new Nokia Data Gathering 4.04 server, the new Windows Phone mobile app, mobile data collection case studies from around the world, and to give you a chance to try out Nokia Data Gathering 4.04 for yourself.

Please join us!

Event	Nokia Data Gathering 4.04 workshop
Date	Wednesday, 16 May 2012
Time	09:00-12:00 AM
Place	Seton Hall University, 400 South Orange Avenue, South Orange, NJ 07079, USA
Room	Beck Rooms A, B, and C (Ground Floor of Walsh Library)

Nokia Data Gathering 4.04 is the result of a collaborative effort between Nokia, the Center for Mobile Research and Innovation at Seton Hall University and Microsoft. Learn more at http://projects.developer.nokia.com/ndg/

For more information about the workshop and/or Nokia Data Gathering, please contact kulsoom.ally 'at' nokia.com

Qt 5 UiHelpers

2012-04-13T18:10:37+00:00

In my previous post I mentioned one of the experiments we are currently working on.
Now it is time to introduce the Qt 5 playground project called UiHelpers – Fortunately, this name will change ;)
Those who follow the Qt development mailing list already read about it, the idea about this post is to reach more people from the community in general.

Context

If you are already familiar with the structure of Qt 5 code, feel free to jump to the next section.

In Qt 4, the whole source code is in the same git repository. The traditional widgets derived from QWidget are part of the QtGui module and represent a central piece for the GUI application development.

In Qt 5, things changed. Qt code were splitted in many repositories which group Qt libraries depending on their functionalities.
Examples of repositories are qtbase, qtdeclarative, qtjsbackend, qtxmlpatterns, qtsvg, qttools, etc.
As you may know, QtQuick 2 became a first class citizen in Qt 5, which means qtdeclarative is one of the main repositories, house of QtQuick and QtQml classes.

But, there are classes that provide the base for QtQuick 2 work properly – they are part of the qtbase repo. There you find QtCore,
QtGui, QtNetwork, QtOpenGL, QtPlatformSupport, QtXml, QtWidgets, etc.

Wait: What’s the difference between QtGui and QtWidgets?

As part of the changes of Qt 5, QtGui is now focused in the basic infrastructure for GUI work on different platforms. For example, it is the place for the platform abstraction layer, window management, image handling, etc.

QtWidgets, as you can conclude based on its name, contains the children of QWidget: QPushButton, QSpinBox, QMainWindow, etc. Also, there are non-widgets classes in QtWidgets, some of them because they are internally too coupled to QWidget classes.

Origins

In this thread it was mentioned the case of QUndoStack, QUndoCommand that are in QtWidgets but can be useful in other contexts where developers do not want to link against QtWidgets just because of this kind of helper classes.
Later, in the change 15857 (with the help of ogoffart), we discussed about moving QUndo* out of QtWidgets. First, we moved these classes to QtGui what as not considered correct given the new motivation of this lib. Then, another idea was to move the classes to a new lib, inside qtbase. It was not considered ideal and the decision was to create a separated repo for these classes, leaving QtWidgets untouched (since the Qt community do not want to introduce new bugs in this lib).

Current status

We set a wiki page where it is possible to check the classes made available out of QtWidgets. Also, there are instructions about where to download the source code, build, test and contact us.

Besides moving classes out of QtWidgets, some prototypes of convenience APIs were created for QtQuick 2 developers and we are very interested in receiving feedback about them. It’s worth mentioning the QML API for UndoStack and the CompletionModel which is based on the internals of QCompleter and was made available in a QML friendly way.

The following example shows a possible use case for the CompletionModel. Improving the models supported by sourceModel is part of the ToDo list. The ListView is going to show the updated list that currently satisfies what is written in the TextInput.

TextInput {
    id: input
}

CompletionModel {
    id: completionModel
    sourceModel: ["Ascension Island", "Andorra", "Afghanistan"]
    completionPrefix: input.text
    caseSensitivity: Qt.CaseInsensitive
}

ListView {
    model: completionModel
    delegate: Text { text: modelData }
}

The two examples bellow show the UndoStack and two items that represent commands. The idea of UndoPropertyCommand is to enable track the changes of some properties. In the example, we are going to track x and y when myRect is moved.

UndoStack {
    id: stack
    undoLimit: 5
}

UndoPropertyCommand {
    id: moveCommand
    properties: ["x", "y"]
}

Rectangle {
    id: myRect

    (...)

    MouseArea {
        (...)
        drag.target: parent
        onPressed: stack.push(moveCommand, myRect);
    }
}

UndoCommand is another element used to represent commands. The difference here is that it allows the customization of the actions onUndo and onRedo the command.

UndoCommand {
    id: aCommand

    onUndo: doAThing(target);
    onRedo: undoAThing(target);
}

Button {
    onClicked: stack.push(aCommand, target);
}

Future

Maybe one day this playground project gets promoted and become a Qt Add-on, but there is no expectation it will happen before 5.0. In the meanwhile, there is a ToDo list with some topics we consider important to handle, like better examples, more tests, docs, etc.

We are looking forward receiving more opinions about this work and, as always, contributors are welcome!

Moving out! :)

2012-04-11T11:12:21+00:00

Hello my fellow readers :)

First of all, this is not a "goodbye" message! It's time to move my blog to a cool domain, which is commonly used by me fellow colleagues Igor Oliveira and Adenilson Cavalcanti. All of my previous posts were moved to there, so don't worry (I mean the CMake tutorials!). So, the new blog link is below:

http://bruno.abinader.com.br

Thank you BlogSpot for hosting this blog for 3 years without problems, and I hope to see you there! :)

Working in the open again

2012-03-27T12:40:01+00:00

Long time since my last post (it’s sad to realize how often I start posts writing this).
Since last year’s Qt Contributors’ Summit, our team at INdT worked on a closed source project – the main reason of the low activity here. At least, I could write some posts for the Qt Labs Blog Brazil, most of them introducing basic concepts about Qt programming and the Qt ecossystem (buzzword++).
The good part is: This project we were working on was developed using Qt and QML for a desktop application. Besides promoting Qt among Brazilian developers and companies, this project helped us to think about improvements for future releases of QtQuick aiming desktop applications. I am looking forward to see a release of this product soon! (However, when it is going to happen is a client decision).

Then, after the end of this project, I finally managed to contribute to Qt5! :-)

Also, in the end of the last year some coworkers started a kind of pet project: It’s called Iceberg, a fork of the Icecream Monitor.

“Why a fork?” Here we use icecream for distributed compilation, many colleagues used to complain about icemon depending on kdelibs. In fact, the code did not use the additional features compared to the equivalent Qt classes. Then, after hugopl started the project, we fixed some issues and added new stuff. The code is here.

I am writing another post to introduce one of our current research projects, which is also part of the proposal I sent to Akademy 2012.

ARM Porting Jam this Friday!

2012-03-02T07:10:26+00:00

For those following the development of the next Ubuntu release (12.04 – Precise Pangolin), you all know that we’re quite close to the release date already, and to make sure Precise rocks since day 0, we all need to work hard to get most of the bugs sorted out during the next few weeks.

At Linaro, the Linaro Developer Platform team will be organizing an ARM porting Jam this Friday, with the goal of getting all developers interested in fixing and working on bugs and portability issues related with the Ubuntu ARM port (mostly issues with ARMHF at the moment).

The idea of having the Porting Jam at Friday is to have it as a joint effort with Ubuntu’s Fix Friday and Ubuntu Global Jam, so expect quite a few other developers helping improving Ubuntu as well!

It’s quite easy to participate:

Check the current bug list for ARM at http://people.linaro.org/~rsalveti/arm-porting-queue/arm-porting-queue-report.html and FTBFS list from http://qa.ubuntuwire.com/ftbfs/
Look at http://developer.ubuntu.com/packaging/html/ for more information about packaging, and how to provide patches and fixes for our current packages
Join #linaro and/or #ubuntu-motu on irc.freenode.net
Grab a bug, debug, ask questions and update the bug report with your findings
Get involved with other developers

Remember that for ARM this release will be a quite huge milestone, as it’ll be the first LTS release supporting ARM, besides delivering support for ARM servers and ARMHF as default, so let’s make sure it rocks!

Looking forward for a great porting Jam!

Happy bug fixing!

SCRUM – primeiros passos

2012-01-23T02:26:46+00:00

Esta semana recebi o e-mail de um amigo que está tentando implantar SCRUM no time que está liderando. Quando trabalhavamos juntos na BRISA tecnologia, fiz uma apresentação sobre o assunto e tentei implantar SCRUM em um dos times. Abaixo seguem alguns links e apresentações que recomendo.

O link abaixo leva para a apresentação que modifiquei para o time do MegaRushing.

Introdução SCRUM – modificado por Alecrim [ PDF ] [ ODP ]

Agora basta agendar o dia e fazer a apresentação.

Ubuntu TV UI at Pandaboard, and next steps

2012-01-16T06:59:56+00:00

Yesterday Canonical announced the first UI concept for the Ubuntu TV. Together with the announcement, the first code drop was released, so we could read and understand better the technologies used, and how this will behave on an ARM environment, mostly at a Pandaboard (that we already have OpenGL ES 2 and video decode working).

Getting Ubuntu TV to work

If are still using Oneiric, you can just follow the guide presented at https://wiki.ubuntu.com/UbuntuTV/Contributing, where you’ll find all needed steps to try Ubuntu TV at your machine.

As it’s quite close with Unity 2D (similar code base), and also based on Qt, I decided to follow the steps described at wiki page and see if it should work correctly.

First issue we found with Qt, was that it wasn’t rendering at full screen when using with latest PowerVR SGX drivers, so any application you wanted to use with Qt Opengl would just show itself on a small part of the screen. Luckily TI (Nicolas Dechesne and Xavier Boudet) quickly provided me a new release of the driver, fixing this issue (version that should be around later today at the Linaro Overlay), so I could continue my journey

Next problem was that Qt was enabling brokenTexSubImage and brokenFBOReadBack for the SGX drivers based on the old versions available for Beagle, and seems this is not needed anymore with the current version available at Pandaboard (still to be reviewed with TI, so a proper solution can be forwarded to Qt).

Code removed, patch applied and package built (after many hours), and I was finally able to successfully open the Ubuntu TV interface at my Panda

UI Navigation on a Pandaboard, with Qt and OpenGL ES2.0

Running Ubuntu TV is quite simple if you’re already running the Unity 2D interface. All you need to do is to make sure you kill all unity-2d components and that you’re running metacity without composite enabled. Other than that you just run ”unity-2d-shell -opengl” and voilà

Here’s a video of the current interface running on my Panda:

As you can see from the video, I didn’t actually play any video, and that’s because currently we’re lacking a generic texture handler for OpenGL ES with Gstreamer at Qtmobility (there’s only one available, but specifically for Meego). Once that’s fixed, the video playback should behave similarly as with XBMC (but with less hacks, as it’s a native GST backend).

Next steps, enabling proper video decode

Looking at what would be needed to finally be able to play the videos, and to make it something useful at your Pandaboard, the first thing is that we need to improve Qtmobility to have a more generic (but unfortunately still specific to Omap) way handle texture streaming with Gstreamer and OpenGL ES. Rob Clark added a similar functionality at XBMC, creating support for ”eglImage”, so we just need to port the work and make sure it works properly with Qtmobility.

Once that’s ported, the video should be streamed as a texture at the video surface, making it also work transparently with QML (the way it’s done with Ubuntu TV).

If you know Qt and Gstreamer, and also want to help getting it to work properly on your panda, here follows a few resources:

Rob’s implementation of eglImage at XBMC: https://github.com/robclark/xbmc/commits/gstreamer-eglimg
Qtmobility support for Meego and OpenGLES: http://qt.gitorious.org/qt-mobility/qt-mobility/blobs/master/plugins/multimedia/gstreamer/qgstreamergltexturerenderer.cpp
IRC: #linaro and #ubuntu-tv at Freenode, look for robclark or rsalveti

As soon video decoding is working properly, a new blog post should be around explaining the details and how to reproduce it at your own Panda with Ubuntu LEB

Cheers!

Ubuntu TV fully accelerated on a Pandaboard with Ubuntu LEB

2012-01-16T06:56:11+00:00

As described on my previous post about Ubuntu TV support on a Pandaboard, we were still missing proper support for texture streaming on a Pandaboard, to have the video playback also working and fully accelerated.

This weekend Rob Clark managed to create the first version of the TI’s specific eglImage support at Qtmobility, posting the code at his gitorious account, and for the first time we’re fully able to use Ubuntu TV on a ARM device, using a Pandaboard.

Demo video with the Ubuntu TV UI (accelerated with Qt and OpenGL ES 2.0) and with video decode support of 720p and 1080p:

The code support for TI’s eglImage still needs a few clean-ups, but we hope to be able to push the support at Ubuntu in the following weeks (make it good enough to try at least a package patch).

For people wanting to try it out, a few packages are already available at Linaro’s Overlay PPA, and the remaining ones should be available later today (Qt and Qtmobility), so people can easily run it with our images.

Hope you enjoy, and we’ll make sure we’re always working on keeping and improving the current support, so Ubuntu TV also rocks with ARM

Cheers!

HW video decode and XBMC support on a Pandaboard with Ubuntu LEB

2012-01-16T02:11:41+00:00

Part of the effort we spent during the Linaro 11.12 cycle was to try to enable at Pandaboard not only hardware graphics support (GLES with PVR SGX), but also hardware accelerated video decode, as TI had released all needed userspace to be used at Ubuntu Oneiric (11.10) release.

Unfortunately it didn’t just work with our images because at that time we were using a newer kernel already, based on the 3.1 series that is maintained by the Linaro TI Landing Team. Bug 880840 has all the details.

Luckily Sebastien Jan (from TI) was able to find the root cause of the problem, that was causing so much frame drops that was making the video playback basically unusable. The problem was related with PM support at omap’s hwspinlock implementation, as you can check at this link.

Kernel fix properly integrated and available at the Overlay PPA used by our Linaro Ubuntu Evaluation Build images, and finally able to have a similar user experience as was expected when TI delivered the user space components at their own PPA.

If you want to try it by yourself, just be sure you’re using at least linux-image-3.1.1-6-linaro-lt-omap at your board (all hwpacks >= 20110105 should have it included by default).

Playing videos with HW decode acceleration

Since today you’ll also easily find all the needed packages to enable HW video decode acceleration at our images (Pandaboard only at the moment, more boards coming soon). We just included and copied all needed packages from the TI PPA, so you don’t even need to enable it when installing the additional packages.

Installing the extra packages for video decode at your Pandaboard:

Grab the latest Pandaboard hwpack (lt-panda-x11-base-oneiric) and Ubuntu Desktop image from http://snapshots.linaro.org/oneiric (as example I used hwpack_linaro-lt-panda-x11-base_20120106-0_armel_supported.tar.gz and linaro-o-ubuntu-desktop-tar-20120105-0.tar.gz)
Create a Ubuntu LEB pandaboard image on a SD card, following the instructions described at https://wiki.linaro.org/Platform/DevPlatform/Ubuntu/ImageInstallation
Boot the card and install the ubuntu-omap4-extras-multimedia package: $ sudo apt-get install ubuntu-omap4-extras-multimedia
Reboot your pandaboard
Play a video with any video player that’s compatible with Gstreamer (e.g. Totem)

In the future we should also have this completely integrated at the hwpack itself, but unfortunately this is not possible at the moment without increasing the image size too much.

XBMC support

Another awesome thing we worked during previous cycle (11.12) was to make an XBMC version available that would use both GLES and Gstreamer, so it could also be used with a Pandaboard. Avik Sil did a great work making it all work with our images, and we were finally able to have XBMC 11 Beta (Eden) available at our Overlay PPA.

For proper support for Gstreamer Rob Clark did an awesome work improving the current patches, and also improving the support quite a bit. At our package you’ll find all latest patches available from Rob, from his current development tree.

To start using XBMC with the Ubuntu LEB image at your Pandaboard, you just need to install the xbmc package, with $ sudo apt-get install xbmc. For best user experience, please use the XBMC session available at LightDM (just log-out the default session and select XBMC instead). This will work a lot better because then there will be no other window manager or compositor taking extra resources from your board.

We also hope to deliver a set-top box image by the end of the current cycle (12.01), that will have XBMC installed by default. Please check the blueprint https://blueprints.launchpad.net/linaro-ubuntu/+spec/create-a-set-top-box-leb-image if you want to follow the progress of it.

Bugs and Issues

Unfortunately not everything is working perfectly at the moment, and issues with the Gstreamer and hw video decode support on Pandaboard are expected. The most annoying one that’s currently affecting XBMC is the issues with seek, as sometimes the video goes faster than the audio, and then it stops for a while until it’s in sync again. We hope to get this fixed soon, but that depends a bit of how much time Rob can spend on it.

In case of any other bug while trying to get video decode to work on your Pandaboard, don’t hesitate to open a bug at https://bugs.launchpad.net/linaro-ubuntu/+filebug or ping aviksil, robclark or rsalveti at #linaro on freenode.

Cheers!

Update: Check bug https://bugs.launchpad.net/linaro-ubuntu/+bug/915456 for the video hanging issue. Without polling XBMC should now play most videos just fine.

Update 2: XBMC-ready image already available at http://snapshots.linaro.org/oneiric/linaro-o-linarotv-xbmc/, just be sure to flash with http://snapshots.linaro.org/oneiric/lt-panda-x11-base-oneiric/.

Update 3: There’s a mem leak at the gst decode codec, check bug https://bugs.launchpad.net/ubuntu-omap4-extras-multimedia/+bug/915768 for progress on that.

Retrospectiva 2011, planos pra 2012

2011-12-31T21:36:29+00:00

Pra não perder a tradição (desde 2006), hora do post de fim de ano: relembrar 2011 e planejar um pouco 2012.

2011 foi um ano excelente pra mim. Um ano pra ser lembrado. Começou com novidades ruins no trabalho no INdT/Nokia: “the burning platform”, a aliança com a Microsoft e o futuro incerto. Pra aliviar um pouco, vieram as férias, uma excelente viagem à Europa com a Viviane: 35 dias intensos, 11 países (França, Inglaterra, Holanda, Alemanha, Russia, Polônia, República Checa, Áustria, Itália e Vaticano — sim, o Vaticano conta!). Ótimas experiências com couchsurfing, muitos kms de estradas, trens, aeroportos… Viagem intensa mas sem nenhum contratempo.

Mosaico com algumas fotos da viagem à Europa

Mais pro final do ano vieram duas grandes e excelentes novidades, quase que simultaneamente:

Estávamos começando a fazer nossos planos pra ter um bebê quando veio a surpresa, mais do que bem vinda: a Viviane estava grávida. Estamos super empolgados e felizes. Em 2012 (abril/maio) deve chegar a Sofia, nossa primeira filha. Foi uma correria pela coincidência com as férias e aproveitamos pra visitar nossos pais (RS e PR). Também fizemos uma viagem rápida aos EUA pra aproveitar nossas últimas férias sozinhos e fazer o enxoval do bebê. Fomos pra Miami e Orlando, aliando compras com alguns passeios.

Mosaico de fotos da viagem à Miami e Orlando

A segunda grande novidade foi a mudança no trabalho: após um longo e criterioso processo de entrevistas (~3 meses), consegui uma vaga na empresa que mais admiro, pra trabalhar numa área na qual eu sempre tive muito entusiasmo mas pouca oportunidade: entrei pra Red Hat como gerente técnico no time de virtualização (kvm e qemu – kernel e afins), um time cheio de grandes talentos com foco nos projetos upstream, um grande desafio. Na Red Hat me senti em casa, como se eu tivesse voltado aos tempos de Conectiva: revi bons e velhos amigos e me identifiquei de imediato com os novos colegas. E no último mês do ano ainda veio mais uma novidade: consegui ser aprovado no processo de seleção do Mestrado em Computação da UFPE/Cin com uma proposta na área de virtualização.

A revisão dos objetivos de 2011 ficou assim:

~~Visitar dois países que eu ainda não conheça;~~ OK – o plano original era ir pra China e Índia, mas os 9 novos países europeus cumprem o objetivo com folga;
Atualizar a seção de fotos do site; FAIL – sem comentários;
~~Visitar nossos familiares e amigos no sul do Brasil;~~ OK – dava pra fazer melhor, mas Viviane foi pro RS e fomos juntos pra Umuarama – PR;
Começar a estudar um novo idioma, junto com a Viviane; FAIL
~~Estudar (formalmente ou não), pois evoluí menos do que esperava em 2010;~~ OK – foquei um pouco nos estudos no final do ano, 2012 com certeza será melhor;
~~Melhorar minha atividade nas “redes sociais”, reforçar antigas amizades;~~ OK – acho que posso melhorar, mas estou no caminho certo…
Comprar algum tipo de tablet, preferivelmente um que sirva como ebook-reader; FAIL – ficou pra 2012, um Kindle está fazendo muita falta.

2012 será muito intenso e com desafios sem tamanho. Mas já começo realizando o tradicional objetivo de conhecer um novo país todo ano: em janeiro vou pra Israel a trabalho. Dessa vez não farei uma lista de planos específicos. Tenho apenas três grandes objetivos, em ordem de prioridade:

Ser um bom pai pra Sofia e um bom marido pra Viviane nessa nova fase de nossas vidas;
Ser um bom profissional na Red Hat, cumprindo com as expectativas e superando minhas limitações;
Conseguir manter um bom ritmo no primeiro ano do mestrado na UFPE/Cin.

É isso aí, um ótimo 2012 pra todos!

Posts possivelmente relacionados:

Link Permanente | 3 commentários
Post tags: retrospectiva

UDS-P/Linaro Connect Q4.11 and 11.11 cycle

2011-12-05T16:54:33+00:00

During the end of October and beginning of November we had the last Linaro Connect for the year. This time we also had it together with the Ubuntu Developer Summit, giving us the opportunity to better discuss the roadmap with both Linaro and the Ubuntu team.

From the Developer Platform team perspective, we had a quite nice week, with demos happening at Monday and Friday (showing people what we’ve been working on), and also sharing some great news with the Ubuntu team, now that Mark Shuttleworth announced that Ubuntu will go to Tablets, TVs and Phones (and ARM for sure will be a huge part of that).

Some nice links and videos of what happened during that week (related with our team):
* Sessions related with the Developer Platform Team (Ubuntu)
* Linaro Demo: Ubuntu Unity with OpenGL ES on Pandaboard
* Linaro Developer Platform Tech Lead Ricardo Salveti Interview at Linaro Connect
* Linaro Connect Q4.11 – Ubuntu LEB tutorial
* Linaro Connect Q4.11 – Interview with Marcin Juszkiewicz

Linaro 11.11 Release

Another quite good achievement for us during November was the 11.11 release.

During this release we had a quite a few great highlights, including some that we were planning for quite a while already:
* Ability to cross build Firefox using Multiarch
* OMAP4 SPL USB Booting, enabling USB boot at Pandaboard
* ARM DS-5 support for the 5.8 release
* CI Builds for Linaro GCC both for cross and native
* And a lot of bug fixes

Now it’s time to get ready to develop the blueprints we’re planning for 11.12, to also make December another great and solid month (will do another post about the 11.12 planning later this one).

Back to life!

2011-11-21T19:08:59+00:00

I am back from my honeymoon and I’m starting to organize my life again!

Meanwhile, we finally released a game that I’m really proud that is called “Incredible Circus”. It’s the kind of game that is really addictive . In three weeks we achieved 200k downloads on Nokia Store and today is available for the N9. It’s also a really good showcase for Qt. If you have a Symbian^3 or MeeGo device, just follow the link to try the game.

You can also check it out on the video below.

Apart from that, I’m updating my machine and as soon as I have a developer environment again I’ll start hacking on Plasma again. Probably fixing some bugs, right Aaron?

Prague, Telepathy and HTML5 IM Client

2011-11-03T12:37:40+00:00

Hey guys!

Last week I’ve attended to GStreamerConf and LinuxConf conferences in Prague, and Siraj and I had the honor of having our current project for Collabora exposed on Collabora’s both. It shared space with two others amazing Collabora‘s demos:

Media Explorer running a Telepathy plug-in, which adds IM and Audio/Video capabilities to the system.
HTML 5 client of a video editor, using GStreamer Editing Services on top of GtkWebkit.

A little bit about Telepathy Webkit Client

During the last few weeks I’ve been working on a Telepathy client, a very special one, written almost only with HTML 5 and Javascript, on top of GTK WebKit and Seed.
The goal of this project was writing a Telepathy based IM client, to run on top of WebKit, and it should be able do make and receive audio and video calls.

GObject introspection magic

The first question to be answered was “How access the Telepathy methods from Javascript?”

And the answer was: GIR and Seed.

As all Gnome developers knows, GObject introspection (GIR) allows us to access a GObject written in C from a scriptable language, such as Javascript. So that’s part of the answer.

And Seed binds those introspected objects on WebKit JavascriptCore, which is pretty much what we wanted to do.

Following a few screen-shots

Contact List

Our first goal was to show the Telepathy’s roaster list on a HTML5 window. For the widgets, we choose to use joApp, which is a quite nice and stable UI library for HTML 5 applications.

Chat Window

What’s a IM client without a Chat window, right?!

The “tpwebkit” application with an opened text channel between two users.

Receiving a call

Telepathy WebKit application acting as a Telepathy approver for audio and video calls

That’s me, from the point of view of my test machine…

The real thing running

If you want to see the real thing running, you can watch this video showing the application during the early development state.

Conclusions and future work

As we can see from now, Telepathy is ready to be use on native and HTML applications.
I really would like to see the current implementation integrated with the bleeding edge RTC API, which some guys are pushing to WebKit. That would be something really awesome.

If you want to try it, you can get the code here and play with it. You’re also going to need a few special changes on Seed package. Check the linuxconf branch here.
Or, if you use Ubuntu, you can add Xavier’s PPA and install the tpwebkit package.

Tangaza or 'announce' in Swahili

2011-10-14T18:54:30+00:00

Despite the rapid growth of mobile data and mobile internet, many (most) people in developing countries do not have access to mobile data. For example in Africa, there are around 45 basic mobile subscriptions but only 2 data subscriptions per 100 inhabitants. Peer to peer communication, voice calls, SMS and 'beeping' are the standard communication tools and techniques currently in use.

The success of Twitter and other group communication tools has been undeniable and the development and introduction of mobile app based messaging systems remains active. But would it be possible to design a group messaging system for people who only have access to a basic feature phone with standard GSM features available on every mobile phone?

Tangaza is a mobile phone based group messaging system targeted at moderately low income users. Through the use of missed calls, a basic SMS command set and concise touch tone menu, Tangaza is designed to enable affordable spoken communication among flexible groups of users. Developed in collaboration between Nokia US and African research units, Nokia Tangaza was piloted in Kenya in 2009 and a research paper (.pdf) on this pilot and on Tangaza's design decisions was presented at the 1st Annual Symposium on Computing for Development in 2010. The software has now been open sourced under the AGPL and I have just submitted an ITP to the Debian Bug Tracker. We aim to have Tangaza in the next Debian release and the Debian VOIP team are helping with this effort.

Tangaza runs on Linux and you will need to have

Perl 5
Python 2.6
MySQL 5.0
Django 1.2
Kannel 1.4.3
Asterisk 1.6.2

installed on your Debian based system if you want to build Tangaza before it reaches the main repositories . You need to

git clone https://github.com/tangaza/Tangaza

git checkout -b upstream --track origin/master

(The '--track' option alters your .git/config file and adds a [branch "upstream"] section telling Git where you fetched it from. That means you can later just say "git pull" and you will get both the 'master' and the 'upstream' repository merged into your repository automatically.)

git checkout master

git-buildpackage --git-ignore-new --git-builder=debuild -i.git -I.git -us -uc

and install the resulting .deb package

During the last development cycle we built Tangaza a web enabled administrative interface in Django where the groups, members and organization information can be modified and the messages (called Tangazo's) can be listened to We also wrote some documentation about the API calls we make available through RPC for developers who want to build applications on top of Tangaza.

There is some interest in using Tangaza as an agricultural early warning system in East Africa. A Humanitarian Innovation Fund expression of interest passed through to a call for a full proposal which is pretty exciting both in terms of potential impact and also for the new features which can be developed with increased funding

It has been a while

2011-09-14T12:24:44+00:00

It has been a while since my last post and a lot happened in the meantime. Just to point a few (in no special order):

11th February for Nokia;
Tokamak;
GSoC;
Qt Contributor Summit;
Qt Open Governance announced;
Desktop Summit;
Release of N9;
Google acquired Motorola;
Plasma Active;
Netflix in Brazil;
Use of Tiny Tiny RSS (my share feed)
…(many other stuff!)

The sad part though is that I haven’t been able to contribute much code to KDE lately. Next month I’m getting married and as you can probably guess, there is a lot of planning going on (and we can’t forget the famous “bridezilla” effect that usually happens with girls before weddings

On the bright side I’ve been working on awesome projects, trying to eat our own dog food (mainly QML). With these projects we are feeling the pieces of Qt/QML that needs some love and we plan that for the next year we will be able to help the Qt Project to solve these ~~small~~ issues that you can only find when you develop real world applications and not developer/designer-wanna-be demos

IMHO that’s one of the skills that is hard to find today on framework developers: most of them didn’t contribute much to KDE in the last years nor developed real applications. Because of this sometimes it gets harder for them to understand a use case or a “complain” about the technology they develop. I hope that with open governance we can get more help about this (and also use more the rule of the “3 examples” before adding new APIs).

I’ve been following closely the development of Plasma Active and the rest of KDE. I still have one item on my TODO list (related to one of our scripts that get the content of qml files that need translation) that I promised to tsdgeos that I would fix ASAP but I just didn’t have the time unfortunately . November seems the month that I will be able to get back to KDE development (after the honeymoon!!).

Well, I think that’s it. I just wanted to make a simple blog post and update my KDE friends

CellarDoor in German plus Debian package

2011-08-17T01:23:10+00:00

Dear friends

Some quick updates on CellarDoor are due. Since last week, it has debian packaging support in the buildsystem, contributed by Milton Soares.

Simply run ‘make deb’ and you are set: a nice debian package is generated at end.

Next, Adriano Cavalcanti contributed another translation to CellarDoor, German:

Thanks to the fact that German has some bigger than average words, it will require some adjustment in some parts of the UI, but so far so good! As soon I finish some missing features, I’m planning to make a ‘non-hackers’ release.

Currently CellarDoor is available in:

English
Brazilian Portuguese
Italian
German

Do you known French or Spanish?

CellarDoor got its second translation: Italian!

2011-08-08T14:16:35+00:00

Friends

Just 1 day after blogging about my pet project CellarDoor, I was contacted by Francesco Frassinelli asking about how to make translations.

The result in the next day can be checked below:

Of course there are some places in the UI that we will need to make minor adjustments, but it certainly is progressing really fast (except for minor UI code glitches, the Italian translation is done).

Do you speak German or French? Want to contribute to OSS/Freesoftware? Let me known.

Presenting CellarDoor

2011-08-06T14:01:43+00:00

Last January I was talking with my friend Wilson Prata about applications. We have partnered a couple of years ago when creating amora (which by the way needs some care urgently, but this is another matter) and he presented to me a concept for a nice and cool new app: CellarDoor.

What is CellaDoor? Well, it is a wine app. Have you ever started a conversation with someone that also appreciate wines and then failed when trying to remember the name of a good wine you tasted a couple of months ago?

Or what about easily exchanging a wine recommendation? Trying to keep notes in a restaurant napkin is not really much effective.

Trying to address this and other user cases, I started to work in the mockups that he had at time. A great UX designer once taught me the value of close cooperation between programmers X designers to create something that looks good and performs well (and I honestly believe that the best way to create an app is to have at least one designer aboard since the very beginning). This is a different approach than the traditional hack-hack-hack then later ask a designer for some cute icons which is, with some exceptions, the rule in OSS/Freesoftware world.

Unfortunately, I lacked enough free time to progress quickly, but I believe that the app has progressed well enough for a public release. You can checkout the project’s webpage.

So, what are the current features? Here they are:

good looking UI with nice usability
create a wine card with basic information (year, name, vineyard, etc)
filter by wine type (e.g. red, white, other)
persistence of data in a sqlite database (which by the way you can edit in the desktop)
Supported platforms: Linux, OSX, Windows 7, Symbian 5th and 3 (e.g N8, N5800, etc)
snap a photo of the bottle/cork in supported platforms (Linux, Symbian). Persistence of this photo is my todo list (hey, I didn’t say that the app is completely done!).

How it looks like? Check it (running in OSX 10.6):

== What about the technology? ==

The magic to support such varying OSes (Linux, Window, OSX, Symbian), form factors (Mobile, Netbook, Desktop) and resolutions (from 360×640, ranging in 1024×800 and up) is that I used Qt/QML for the UI. At time that I started, Qt Components were not ready yet, so I got to implement my own (probably buggy) widgets like a combobox (based in joint work with my other friend Ricardo Sato) and a calendar widget (coded together with my friend Igor Trindade), this last widget deserves to be pictured bellow:

== What is next? ==

A long backlog indeed waits in the issue tracker of the project. Between those, I believe that next steps should be:

Packaging: for symbian I have it done (self signed), Window7 I played with WiX to create an installer but I need help for testing. OSX packaging (.dmg) and rpm/deb help would be greatly appreciated;
Translation: it currently supports English and Brazilian Portuguese. I believe it would be cool to support other languages (French, Italian, German);
Coding: there are several features that would be awesome to have, if you are interested, let me known.

So, since ATM there aren’t public packages yet, I guess this is a ‘hacker’s only release’. What you need to compile it is Qt 4.7.x and if in Linux, Qt Mobility 1.1.

Concerning the license, it is good and old GPL v2 code with CC non-commercial for the artwork.

Long time no see you

2011-08-05T22:44:29+00:00

It is being almost one year without posting in my blog… What else to say, besides I have being busy? Since my last post, I have:

a) Trying to be a not so lousy father;

b) Led 2 teams in 2 different projects at same time at OpenBossa (both non-oss, targeting Symbian and Maemo respectively);

c) Visited Boston, Brussels, Miami, London, Bristol, Jericoacoara;

d) Improving my old motorcycle with new accessories;

e) Bought a Brazilian off road “car” and travelled through the country side;

f) Moved to a new apartment, with space for a small office;

g) Since just motorcycling is not enough, tried some new things:

h) After learning QML, decided to write a new pet project (details in the next post!)

i) Reviewing and merging several patches in libgcal (news soon!)

And probably some other stuff that I plainly forgot. Now, I’m planning to post once in a while to not let my blog to collect dust… after all, like I said way back in September 2009: “… having a half-alive, half-dead, zoombie-like blog is worst than having no blog at all.”.

launchpadlib: creating a changelog for a PPA

2011-07-19T03:34:58+00:00

As at Linaro we usually work with many PPAs over the releases, there was a need to generate a proper changelog for a PPA, in a way we could know what packages got changed before doing the release.

At first I thought I could just parse the repository metadata (as a PPA is nothing more than a debian repository), but then I realized I could just use the awesome (yes, *awesome*) launchpadlib, if it had a way to get the data I needed.

So I called the launchpadlib master I know (Ursinha), and in 15 minutes we saw that we could use it to parse the “.changes” file, and from there get the data I needed. As Launchpad stores the PPA packages publishing history, it’s quite easy to get all the changes over period of time.

A few minutes later (after also noticing that there’s a python-debian module to parse the changes file), I created the first version of the generate-ppa-changelog.py script, that does exactly what I needed, and with just a few python lines

Here’s the link: http://bazaar.launchpad.net/~rsalveti/+junk/launchpad/view/head:/generate-ppa-changelog.py.

Usage:

rsalveti@evatp:~/projects/launchpad/scripts$ python generate-ppa-changelog.py -h
usage: generate-ppa-changelog.py [-h] [-d YYYYMMDD] [-s SERIES] -t TEAM
[-p PPA] [--version]

Print Changelog for a PPA

optional arguments:
-h, –help show this help message and exit
-d YYYYMMDD, –date YYYYMMDD
start date to probe for changes
-s SERIES, –series SERIES
ubuntu series to look for changes (default: natty)
-t TEAM, –team TEAM launchpad team that owns the PPA
-p PPA, –ppa PPA ppa name to probe the changelog (default: first PPA)
–version show program’s version number and exit

If no argument is given, it will probe all the changes for the default series.

Output Example:

rsalveti@evatp:~/projects/launchpad/scripts$ python generate-ppa-changelog.py -t linaro-maintainers -p overlay -s natty -d 20110701
Changelog for linaro-maintainers’s overlay PPA (series natty) since 2011-07-01 00:00:00

base-files (5.0.0ubuntu28linaro3) natty; urgency=low

* Updating Linaro LEB version to 11.07 (development branch)

— Ricardo Salveti de Araujo Fri, 15 Jul 2011 04:19:40 -0300

libjpeg-turbo (1.1.1-1inaro2) natty; urgency=low

* release
* add timestamp code to cjpeg.c
* default cjpeg.c and djpeg.c timestamp code to off

— Tom Gall Mon, 11 Jul 2011 20:32:23 +0000

linaro-meta (017) natty; urgency=low

* Refreshed dependencies
* Added libjpeg-turbo62 to linaro-alip, linaro-graphical-engineering,
linaro-multimedia-engineering, linaro-ubuntu-desktop

— Tom Gall Wed, 13 Jul 2011 15:41:29 +0000

u-boot-linaro (2011.07.1-0ubuntu1~natty1) natty; urgency=low

* New upstream 2011.07.1 which includes
– PXE FDT fix from previous ubuntu release so patch has been removed
– Added missing PXE env vars (LP: #808815)
– Generated unique usbethaddr (LP: #809015)
– Modify pxe command to look for usbethaddr if ethaddr is NULL

— John Rigby Wed, 13 Jul 2011 23:31:39 -0600

x-loader (1.5.1+git20110715+fca7cd2-1ubuntu1~natty1) natty; urgency=low

* New upstream release
– several fixes for panda and igep
– OMAP3 code cleanup
– Beagle Rev C5 support
– Support for IGEPv3 board

— Ricardo Salveti de Araujo Fri, 15 Jul 2011 05:55:09 -0300

x-loader (1.5.0+git20110714+cdc887b-1ubuntu1~natty1) natty; urgency=low

* New upstream release
– Adding support for IGEPv3 board
* debian/patches/01-Beagle-Rev-C5-support.patch:
– Adding support for the new Beagle C5

— Ricardo Salveti de Araujo Fri, 15 Jul 2011 02:36:58 -0300

And now we can just generate the proper changelog anytime we want to do a call for testing or a Linaro Ubuntu release

Net booting with TFTP and PXE with Pandaboard

2011-07-11T09:38:44+00:00

Over the past month I’ve being working with John Rigby to integrate the SMSC95XX and OMAP4 EHCI patches into Linaro U-Boot, so we could deliver the network booting feature for people using Pandaboards.

Those patches are published at the U-Boot mailing list, but still as a working in progress. While we work helping the original developers to get the patches accepted upstream, we also want to deliver the functionality for our users, so all those patches are now integrated at the Linaro U-Boot tree.

You can check the patches by going at http://git.linaro.org/gitweb?p=boot/u-boot-linaro-stable.git;a=shortlog.

Testing with Pandaboard

To make it work properly, besides using Linaro U-Boot you’ll also need to use the upstream X-Loader tree, with one additional patch that’s not yet merged. You can clone the upstream tree from http://gitorious.org/x-loader/x-loader, then just apply the patch http://people.canonical.com/~rsalveti/pxe/0001-omap4-pandaboard-ehci-fref_clkout-per-board-revision.patch and build for the Pandaboard target.

If you just want to test without building your own X-Loader and U-Boot, you can just grab both files from http://people.canonical.com/~rsalveti:

X-Loader: http://people.canonical.com/~rsalveti/pxe/MLO
U-Boot: http://people.canonical.com/~rsalveti/pxe/3/u-boot.bin

Building your TFTP + DHCP server for PXE

To build your TFTP + DCHP server just follow the instructions described at https://help.ubuntu.com/community/Desktop/PXE. Don’t worry about the ‘filename “pxelinux.0″;’ line at the dhcpd.conf file, you can remove it.

Then just create your PXE config file at the right place:

$ cat /tftpboot/pxelinux.cfg/0A2A2B0A
default panda-natty
prompt 0
timeout 3

label panda-natty
kernel panda/uImage
append console=ttyO2,115200n8 root=/dev/mmcblk0p2 ro fixrtc vram=48M omapfb.vram=0:24M mem=1G@0×80000000 text earlyprintk=ttyO2
initrd panda/uInitrd

PXE Booting

With the proper X-Loader and U-Boot files in place (at your first SD card partition), and with the TFTP + DHCP server also properly installed, you can just jump and try TFTP/PXE boot.

Stop the U-Boot autoload and call the following commands:

setenv pxecfg_ram 0×88000000: location in RAM to load the pxecfg file
setenv kernel_ram 0×80000000: location in RAM to load the kernel
setenv initrd_ram 0×81600000: location in RAM to load the initrd
setenv autoload no: disable autoload while calling bootp (so you can just set up your network without autoboot)
usb start: start USB and enables the SMSC95xx ethernet interface
bootp: initialize the network, probing the ip address settings from your DHCP server
pxecfg get: probe the pxecfg config file
pxecfg boot: boot

You should get a similar output as:

Texas Instruments X-Loader 1.5.0 (Jul 11 2011 – 07:52:49)
Reading boot sector
Loading u-boot.bin from mmc

U-Boot 2011.06 (Jul 11 2011 – 02:49:51)

CPU : OMAP4430
Board: OMAP4 Panda
I2C: ready
DRAM: 1 GiB
MMC: OMAP SD/MMC: 0
Using default environment

In: serial
Out: serial
Err: serial
Net: No ethernet found.
Hit any key to stop autoboot: 0
Panda # setenv pxecfg_ram 0×88000000
Panda # setenv kernel_ram 0×80000000
Panda # setenv initrd_ram 0×81600000
Panda # setenv autoload no
Panda # usb start
(Re)start USB…
USB: Register 1313 NbrPorts 3
USB EHCI 1.00
scanning bus for devices… The request port(2) is not configured
EHCI timed out on TD – token=0x80008c80
The request port(2) is not configured
4 USB Device(s) found
scanning bus for storage devices… 0 Storage Device(s) found
scanning bus for ethernet devices… 1 Ethernet Device(s) found
Panda # bootp
Waiting for Ethernet connection… done.
BOOTP broadcast 1
DHCP client bound to address 10.42.43.10
Panda # pxecfg get
missing environment variable: pxeuuid
missing environment variable: ethaddr
Retreiving file: pxelinux.cfg/0A2A2B0A
Waiting for Ethernet connection… done.
Using sms0 device
TFTP from server 10.42.43.1; our IP address is 10.42.43.10
Filename ‘pxelinux.cfg/0A2A2B0A’.
Load address: 0×88000000
Loading: #
done
Bytes transferred = 239 (ef hex)
Config file found
Panda # pxecfg boot
Hit any key to stop autoboot: 0
Label: panda-natty
kernel: panda/uImage
append: console=ttyO2,115200n8 root=/dev/mmcblk0p2 ro fixrtc vram=48M omapfb.vram=0:24M mem=1G@0×80000000 text earlyprintk=ttyO2
initrd: panda/uInitrd
Retreiving file: panda/uInitrd
Waiting for Ethernet connection… done.
Using sms0 device
TFTP from server 10.42.43.1; our IP address is 10.42.43.10
Filename ‘panda/uInitrd’.
Load address: 0×81600000
Loading: #################################################################
#################################################################
#################################################################
#################################################################
############
done
Bytes transferred = 3982715 (3cc57b hex)
Retreiving file: panda/uImage
Waiting for Ethernet connection… done.
Using sms0 device
TFTP from server 10.42.43.1; our IP address is 10.42.43.10
Filename ‘panda/uImage’.
Load address: 0×80000000
Loading: #################################################################
#################################################################
#################################################################
#################################################################
#########################
done
Bytes transferred = 4174480 (3fb290 hex)
## Booting kernel from Legacy Image at 80000000 …
Image Name: Ubuntu Kernel
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 4174416 Bytes = 4 MiB
Load Address: 80008000
Entry Point: 80008000
Verifying Checksum … OK
## Loading init Ramdisk from Legacy Image at 81600000 …
Image Name: Ubuntu Initrd
Image Type: ARM Linux RAMDisk Image (uncompressed)
Data Size: 3982651 Bytes = 3.8 MiB
Load Address: 00000000
Entry Point: 00000000
Verifying Checksum … OK
Loading Kernel Image … OK
OK

Starting kernel …

Uncompressing Linux… done, booting the kernel.
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
…

This should be enough for you to get your Pandaboard booting with PXE. You can also script these commands at your boot.scr file that U-Boot loads automatically from your SD card, so you don’t have to call them by hand every time you reboot your board.

In case it doesn’t work for you, just ping me (rsalveti) at #linaro on freenode

Qt Contributors’ Summit

2011-06-17T12:22:07+00:00

We are in Berlin, attending the Qt Contributor’s Summit. 265 people are discussing very important (and interesting) topics for Qt 5 and the open governance. You can follow what’s happening here using the hash code #qtcs on several social networks. And of course, you can check the wiki page of the event.

Personally, I am attending sessions related with QML, Qt-Components, DevNet and open governance.

And yesterday was Thursday, also known as the “Yellow Day”:

Ok, Ademar was not wearing yellow t-shirt. Well, imagine him as the goalkeeper of the team ;)

Managing multiple network profiles using upstart

2011-06-07T03:26:16+00:00

One of the purposes of buying the Jetway mini-top HBJC600C99-352-BW was using it as wireless router. I installed Ubuntu 11.04 on it. As NetworkManager does not handle wireless interfaces in access point (AP) mode, I decided to design my own network management. The idea is simple: use the required daemons/application and create upstart jobs to handle the activation logic. These are the network profiles I want to support:

WIFI: The htpc will connect to any known AP available.
ADSL: The htpc will connect to Internet via ADSL and act as a wireless router.
3G: The htpc will connect to the Internet via 3G and act as a wireless router.

List of applications I need to use:

upstart;
wpa_supplicant;
dhclient;
brctl;
ifconfig;
hostapd;
dhcpd;
pppd;
iptables;
dnsmasq.

To install the needed packages, type the application name in the terminal. Ubuntu will help you with package’s name.

There are thousand ways to do that using upstart, so let me list some constraints I kept in mind when designing the system:

Customized solution. I believe that generic solutions must be used only when you really need them. Every time you make something more generic you end up adding more logic, creating more corner cases and spending more time with use cases that you will NEVER face. Example of assumptions: my built-in ethernet port is eth0, my wireless interface wlan0 is NOT hotplug.
Always have a maintenance channel available. Shit happens, all the time. So independent of the network profile I choose I want some way to get a secure shell connection without connect a keyboard (that I don’t have) to the htpc.
One upstart job per long lived process. Among the applications listed above, some have short lifetime, i.e. they set some configuration and/or perform some action and finish. Others keep running until some orderly finish action. I decided that the formers don’t need to be a job, they can be run as pre or post scripts of other jobs.

1st step: Get rid of Ubuntu networking jobs.

I will manage my network stuff using only upstart jobs, so I don’t need network-manager and ifupdown utilities. So lets disable them:

root$ echo manual >> /etc/init/networking.conf
root$ echo manual >> /etc/init/network-interfaces.conf
root$ echo manual >> /etc/init/network-manager.conf
root$ echo manual >> /etc/init/networking.conf
root$ echo manual >> /etc/init/bridge-network-interface.conf

Now, we need a job to raise the loopback interface. The following job is completely based on the Ubuntu’s network-interface job:

/etc/init/loopback.conf

start on net-device-added INTERFACE=lo
stop on net-device-removed INTERFACE=lo

pre-start script
    mkdir -p /var/run/network
    ifconfig lo 127.0.0.1 up
    initctl emit -n net-device-up IFACE=lo LOGICAL=lo
                                  ADDRFAM=inet METHOD=loopback
end script

post-stop exec initctl emit -n net-device-down IFACE=lo LOGICAL=lo
                                               ADDRFAM=inet METHOD=loopback

As upstart will run and take care of all daemons listed above, we must disable the sysinit scripts that start/stop them (that ones in /etc/init.d).

root$ update-rc.d -f hostapd remove
root$ update-rc.d -f isc-dhcp-server remove
root$ update-rc.d -f dnsmasq remove

2nd step: create mutually exclusive jobs to set the network profile.

/etc/init/net-profile-adsl.conf

stop on (starting net-profile-adsl
         or starting net-profile-wifi)
# the 'start on' below means "i'm the default profile"
start on (local-filesystems
          and net-device-added INTERFACE=wlan0
	  and net-device-added INTERFACE=eth0)

etc/init/net-profile-3g.conf

stop on (starting net-profile-3g
         or starting net-profile-wifi)

/etc/init/net-profile-wifi.conf

stop on (starting net-profile-3g
         or starting net-profile-adsl)

The main ideia of this arrangement is to change the profile using a single command. For instance, if somehow my adsl connection become unavailable I just need to connect my cell phone to the htpc and run the following command:

root$ start net-profile-3g

To reach this goal, all the following jobs will depend on this set of “fake” jobs as you can see in the next steps.

3rd step: set-up the bridge

First, the question. Why do I need a bridge? It’s because I have a printer connected to the htpc via ethernet. As I only have one built-in ethernet port I bought a usb-ethernet adapter (eth1). So, every time the htpc is running the 3g or adsl profile, I want wlan0 and eth1 in a bridge to route the connection to them. I can even say that everytime I plug-in the usb-ethernet adapter, I want dhcpd sending valid IP addresses to it (do you remember that I want a ssh access anytime?). The solution that I chose:

The bridge (br0) will be set up at startup time and dhcpd will be configured to manage this interface
Whenever the usb-ethernet is plugged in, its interface will be added to the bridge
Every time ADSL or 3G profiles are chosen, wlan0 will also be added to the bridge

/etc/init/bridge.conf

start on started loopback
stop on stopping loopback

pre-start script
    brctl addbr br0
    ifconfig br0 10.0.1.1 netmask 255.255.255.0 broadcast 10.0.1.255
end script

post-stop script
    ifconfig br0 down
    brctl delbr br0
end script

/etc/init/usb-ethernet.conf

start on net-device-added INTERFACE=eth1
stop on net-device-removed INTERFACE=eth1

pre-start script
    ifconfig eth1 up
    brctl addif br0 eth1
end script
post-stop exec brctl delif br0 eth1

/etc/init/dhcpd.conf

start on started bridge
stop on stopping bridge

exec dhcpd -f

Note that the configurations above do not show when the wlan0 interface is added to the bridge. It will be covered in the next steps. Do not forget to change /etc/default/isc-dhcp-server in order to make dhcpd manage the br0 interface. Also, you need a valid configuration in the /etc/dhcp/dhcpd.conf. I will show my config below:

ddns-update-style none;

option domain-name-servers 10.0.1.1;

default-lease-time 600;
max-lease-time 7200;

authoritative;

log-facility local7;

subnet 10.0.1.0 netmask 255.255.255.0 {
  range 10.0.1.10 10.0.1.254;
  option routers 10.0.1.1;
}

4th step: managing wlan0 when the WIFI profile is chosen

Basically I need wpa_supplicant and dhclient running on wlan0 interface. Also, I need to keep wlan0 out of the bridge. Dumping the config:

/etc/init/wpa_supplicant.conf

start on started net-profile-wifi
stop on stopping net-profile-wifi

exec wpa_supplicant -iwlan0 -Dnl80211 -c/etc/wpa_supplicant.conf

/etc/init/dhclient.conf

start on started wpa_supplicant
stop on stopping wpa_supplicant

exec dhclient -d wlan0

emits net-device-up
emits net-device-down

post-start exec initctl emit -n net-device-up IFACE=wlan0 LOGICAL=wlan0
                                              ADDRFAM=inet METHOD=dhcp
pre-stop script
    ifconfig wlan0 0.0.0.0
    initctl emit -n net-device-down IFACE=wlan0 LOGICAL=wlan0
                                    ADDRFAM=inet METHOD=dhcp
end script

Note that you need a valid /etc/wpa_supplicant.conf file in order to be able to connect to a known AP. I don’t think I need to paste my config here. If you have any doubts run ‘man wpa_supplicant.conf’.

5th step: managing wlan0 when either 3G or ADSL profiles are chosen

I only need to launch hostpad and to add wlan0 to the bridge (br0). The job configuration:

/etc/init/hostapd.conf

start on (started net-profile-3g
          or started net-profile-adsl)
stop on (stopping net-profile-3g
         or stopping net-profile-adsl)

exec hostapd /etc/hostapd.conf

post-start script
    while [ "`iw wlan0 info | grep type | cut -d ' ' -f 2`" != "AP" ]; do
        sleep 0.5
    done
    brctl addif br0 wlan0
end script
pre-stop exec brctl delif br0 wlan0

Note how wlan0 is added to the bridge. The current solution is a ugly hack that I’m planning to improve further… The problem is that a wireless interface in ‘managed mode’ cannot be added to a bridge. So when I move from WIFI profile (the wlan0 is in managed mode) to 3G or ADSL profile (wlan0 is in master mode), the brctl addif command fails. The reason is that hostapd daemon does not have enough time to set the master mode before its own post-start script runs.

Lets remind you again about valid configuration files… My wireless device uses ath9k kernel driver and below I’m pasting my hostapd.conf

/etc/hostapd.conf

interface=wlan0
bridge=br0
driver=nl80211

ssid=myssid
hw_mode=g
channel=1

wme_enabled=1
ieee80211n=1
ht_capab=[HT40+][SHORT-GI-40][TX-STBC][RX-STBC1][DSSS_CCK-40]

macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=come_on
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

6th step: managing ppp0 interface when either ADSL or 3G profiles are chosen

I only need to call pppd with the desired profile and create a NAT using iptables. There are bare differences between 3g and adsl pppd jobs as you can notice below:

/etc/init/pppd-gvt.conf

start on started net-profile-adsl
stop on stopping net-profile-adsl

emits net-device-up
emits net-device-down

pre-start exec ifconfig eth0 0.0.0.0 up

exec pppd call gvt

post-start script
    iptables -t nat -A POSTROUTING -s 10.0.1.0/24 -o ppp0 -j MASQUERADE
    iptables -A FORWARD -s 10.0.1.0/24 -o ppp0 -j ACCEPT
    iptables -A FORWARD -d 10.0.1.0/24 -m conntrack
                --cstate ESTABLISHED,RELATED -i ppp0 -j ACCEPT
    initctl emit -n net-device-up IFACE=ppp0 LOGICAL=ppp0
                                  ADDRFAM=inet METHOD=ppp
end script

pre-stop script
    iptables -F
    initctl emit -n net-device-down IFACE=ppp0 LOGICAL=ppp0
                                    ADDRFAM=inet METHOD=ppp
end script

pre-start exec ifconfig eth0 down

/etc/init/pppd-vivo3g.conf

start on started net-profile-3g
stop on stopping net-profile-3g

emits net-device-up
emits net-device-down

exec pppd call vivo3g

post-start script
    iptables -t nat -A POSTROUTING -s 10.0.1.0/24 -o ppp0 -j MASQUERADE
    iptables -A FORWARD -s 10.0.1.0/24 -o ppp0 -j ACCEPT
    iptables -A FORWARD -d 10.0.1.0/24 -m conntrack
                --cstate ESTABLISHED,RELATED -i ppp0 -j ACCEPT
    initctl emit -n net-device-up IFACE=ppp0 LOGICAL=ppp0
                                  ADDRFAM=inet METHOD=ppp
end script

pre-stop script
    iptables -F
    initctl emit -n net-device-down IFACE=ppp0 LOGICAL=ppp0
                                    ADDRFAM=inet METHOD=ppp
end script

Important notes:

My adsl modem is in bridge mode and connected to eth0 port.
GVT is my adsl provider name and Vivo3G is my 3G operator name

Configs to adsl connection:

/etc/ppp/peers/gvt

noipdefault
defaultroute
hide-password
noauth
usepeerdns
user "turbonet@turbonet"
plugin rp-pppoe.so eth0
remotename gvt
ipparam gvt

Add the following line to /etc/ppp/pap-secrets

"turbonet@turbonet" gvt "gvt25"

Configs to 3G connection:

/etc/ppp/peers/vivo3g

hide-password
noauth
connect "/usr/sbin/chat -v -f /etc/chatscripts/vivo3g"
/dev/ttyACM0
115200
defaultroute
noipdefault
user "vivo"
remotename vivo3g
ipparam vivo3g
usepeerdns

/etc/chatscripts/vivo3g

ABORT BUSY ABORT 'NO CARRIER' ABORT VOICE ABORT 'NO DIALTONE' ABORT 'NO DIAL TONE' ABORT 'NO ANSWER' ABORT DELAYED
'' ATZ
OK AT+CGDCONT=1,"IP","zap.vivo.com.br"
OK "ATDT*99#"
CONNECT ''

Add the following line to /etc/ppp/pap-secrets

"vivo" vivo3g "vivo"

7th (and last) step: Setup local dns server

To configure the htpc to run as a name server, I’m using dnsmasq:

/etc/init/dnsmasq.conf

start on started loopback
stop on stopping loopback

exec dnsmasq -k -u dnsmasq -7 /etc/dnsmasq.d,.dpkg-dist,.dpkg-old,.dpkg-new

/etc/dnsmasq.conf

interface=br0
no-dhcp-interface=br0

If you want to use dnsmasq locally, add this line to your /etc/dhcp/dhclient.conf

prepend domain-name-servers 127.0.0.1;

That’s all. This setup is not fully tested (stressed). If you read/applied this and have some suggestions, please reply here

New gadget!

2011-05-31T01:44:19+00:00

I was looking for a computer with following features:

Act as a wireless router
Act as a multimedia center (1080p)
Quiet
Low power consumption

After some research, I chose the Jetway Mini-Top HBJC600C99-352W-BW.

Software solution: Ubuntu 11.04 + XBMC. The installation has worked out of the box, no main issues. XBMC standalone is launched by default. Nice job xmbc team!!! The software is awesome.

In the following posts I will show how I customized Ubuntu to make it fit my requirements

Meego Conf 2011 – San Francisco

2011-05-23T13:00:25+00:00

I am in San Francisco (again! =), now for the MeeGo Conference 2011.

The event is about to begin with the keynote “The Future of MeeGo Starts Now” presented by the president of Linux Foundation, Jim Zemlin.

This time, I’m going to present a talk in the event too! The talk is today and the topic is “Writing applications for multiple MeeGo devices”.

There are other talks by openBossa/INdT guys, check the schedule!

Evaluating projects for their return on social investment

2011-04-25T17:23:01+00:00

I have just published the software I wrote for my MBA in Strategic Management of Technology Innovation.

A slightly customized version of the software is currently in use as a innovation funnel at INdT.

It is a commonly accepted fact in business that social projects bring some tangible beneﬁts to an organization. Unfortunately, even if the project is very successful this often does not impact directly on the ﬁnancial bottom line. And, in a world of razor-thin margins, a set of activities that drive up corporate cost without any directly identiﬁable return is a tough sell, no matter how worthwhile and noble the project might be. The business case for social projects is therefore contingent on ﬁnding a suitable method for valuation — one that allows managers to understand the implications of an indirect beneﬁt and then make ’intelligent’ decisions about which projects to choose and the most feasible level of resources to commit.

I approached the problem using techniques from agile development. Scrum sizings were run with stakeholders experienced in the type of project under evaluation which estimated the intangible values present in the social project.The values were then passed into an algorithm which ran an economic analysis of the project with its associated series of estimates as projected 'cash-flows'. The economic indicators calculated are net present value, internal rate of return and eﬃciency of investment

Projects are then ranked on their efficiency of social investment score.

The customization used at INdT is that instead of using scrum estimates the software has values assigned by answering questions. This makes the software then useful for all kinds of projects.The following questions were used

What is the quality of information presented.?
How much does this project align with strategy?
What is the probability that the project will build competencies?
The project opens new, significant markets for customers (What is the potential for market and revenue creation?)
What is the project's capacity to leverage competitive position (Impact on competition)
If the project is approved what is the span of possible applications that the resulting product might be applied to?
Are there any IPR implications?
What is the technological feasibility of the project?
Assuming the project is implemented the set up costs of it are likely to be?
What are the technological risks?

and the software also has a 'stage-gate' built in now so that projects can be eliminated early on if some basic requirements are not met. Things like the project conflicting with the current portfolio or not adding value fit this description.

The software is published under the AGPL and it uses a standard Django set up. It should be relatively bug free but YMMV depending on what you want to do with it. The full thesis - How to choose social investment projects by calculating their eﬃciency of investment using agile software development techniques - is available to download here. Enjoy!

Google Summer of Code: PySide under PSF umbrella

2011-03-29T16:49:04+00:00

PySide was accepted as a project under PSF umbrella. Any student who want to submit ideas related with PySide can contact us, or any PySide mentor, to discuss the ideas and prepare some proposals. Feel free to propose new ideas, do not get stuck only in the current ones be creative and good luck. You can get more information on Python GSoC wiki, PySide GSoC wiki, and #pyside on freenode.

Software shortlisted for sustainability award

2011-03-11T15:32:11+00:00

NDG has been shortlisted for the Just Means 2011 – Social Innovation Awards, an important program which recognizes innovative software in the social and environmental areas. The result will be published during the event “2011 Redefining Value”, which will occur on the 25th of March, in London.

The software is competing in the category ‘Most Strategic Use of Philanthropic Funds’, disputing the prize with other three companies – Nature’s Path Foods, Oracle Corporation and Barclays PLC.

“The initiative to submit NDG to the prize came from Nokia's Corporate Social Investment team. Those involved believe that the work done recently with the software has brought many positive effects to communities in need worldwide and for this reason we have the potential to compete,” explains Ian Lawrence, a software developer at INdT, whom along with Rodrigo Ramos – also an INdT developer – works on the NDG project in Manaus, developing new features and offering support to NGOs and companies which wish to use the tool.

NDG was launched in 2008, and it is used for the collection of field data, substituting the use of paper survey forms and allowing the secure transfer of this information to a server, in real time. In 2009, the State of Amazonas’ Secretary of Health (SUSAM) adopted the software to conduct a campaign to fight Dengue Fever in Amazonas.

The results were so significant that NDG was adopted worldwide by many different organizations. Examples are the Philippines’ Government who along with the WWF use the tool to map the agricultural sector in the country and the Kenyan Government who run child birth registration programs in rural areas.

Python bindings para libepub usando Shiboken

2011-03-09T03:10:12+00:00

Tenho um Kindle, gosto muito dele, mas infelizmente não posso dizer o mesmo sobre o formato usado para os livros. Não que eu tenha feito um estudo detalhado do formato mobi e chegado a conclusão que ele é tecnicamente inferior. Não. O problema é que ePub é tão mais popular, o que significa mais livros, e mais ferramentas com as quais brincar. Calibre é ótimo para converter formatos de eBooks, mas eu prefiro a simplicidade de baixar um livro, copiar pro dispositivo e já sair lendo.

Quando meu Kindle não está à mão, meu leitor substituto é um N900 com MeBook, um dos meus aplicativos preferidos – ele procura por livros (no formato ePub) no Feedbooks, baixa pro dispositivo e os mostra numa lista bem bacana, com capas e tudo. Examinando o código fonte do MeBook aprendi que ele usa a libepub para ler eBooks ePub, então pensei que seria interessante fazer bindings Python para libepub. E aqui estamos.

Ah, e mais uma coisa antes de começarmos, encontrei um projeto Python no github chamado libepub. Não verifiquei ainda, mas o menciono aqui pelo bem da informação.

Shiboken

Shiboken é a ferramenta de renome mundial usada para gerar o mundialmente famoso PySide (que ocore ter alcançado a versão 1.0 semana passada – viva!) Ela é uma das melhores ferramentas disponíveis para gerar bindings Python para bibliotecas C++. Mas isso sou eu falando – eu nela. Contudo, libepub é escrita em C, e mesmo que Shiboken possa gerar bindings para um punhado de funções globais e juntá-las num módulo Python, fica uma porcaria. De forma que terei de fazer algumas preparações para que a libepub apareça bela em Python.

Pré-requisitos: arquivos de desenvolvimento (i.e. os cabeçalhos) para ApiExtractor, GeneratorRunner, Shiboken, e libepub. (Para usuários de Debian/Ubuntu isto significa: libapiextractor-dev, libgenrunner-dev, libshiboken-dev, and libepub-dev.) E o compilador C++ mais o CMake, é claro.

Lembrete: ApiExtractor, GeneratorRunner e Shiboken são feitos com Qt (somente módulos principais, nenhuma delas tem ui), mas os bindings gerados não dependem da Qt de forma alguma. Exceto, obviamente, se a biblioteca para qual os bindings serão gerados já a use.

libepub

Primeiro, vamos dar uma olhada na libepub. Ela tem três estruturas usadas como ponteiros opacos:

// Contem informacao sobre o arquivo ePub.
struct epub;
// Objeto iterador para o indice.
struct titerator;
// Objeto iterador para o conteudo do livro.
struct eiterator;

Se você quiser ler o conteúdo de um arquivo ePub, chame a função que irá criar uma estrutura epub, itere por seu índice com um titerator, e depois pelos conteúdos mesmos usando um eiterator.

A maioria das funções seguem aquele formato “C orientado a objetos” visto em outras bibliotecas, com o primeiro argumento sendo um ponteiro para a estrutura que representa o “this” ou “self” em linguagens OO. Exemplos:

void
epub_dump(struct epub* epub);

unsigned char**
epub_get_metadata(struct epub* epub,
enum epub_metadata type,
int* size);

int
epub_get_data(struct epub* epub,
const char* name,
char** data);

CMake

Usarei CMake como o sistema de compilação dos bindings pois me sinto confortável com ele – é o mesmo usado no PySide e no conjunto de ferramentas de geração do Shiboken. Não darei muita atenção à esta parte do processo, apenas veja os arquivos CMakeLists.txt; explicação mais detalhada sobre o processo de compilar um binding pode ser encontrada em PySide Binding Generation Tutorial. Para informação realmente básica, veja PySide CMake Primer.

C++ Wrapper feito à mão para uma biblioteca em C

Para gerar bindings Python para uma biblioteca C++, o sujeito precisa escrever uma descrição XML chamada type system, que declarará o quê precisa ser exposto para Python, e o quê sofrerá modificação: funções globais, classes, namespaces, enums. Por exemplo, se em C++ temos a classe Rectangle, eu a declararia no type system dessa forma:

<value-type name='Rectangle' />

Todos os métodos pertencentes à Rectangle serão expostos em Python automaticamente. O mesmo não vale para as funções em C que representam os métodos para a estrutura epub. Infelizmente não há modo de dizer para o gerador Shiboken que quero a estrutura epub e suas funções representadas como uma classe com métodos, sendo assim precisamos escrever um fino envoltório C++ ao redor das estruturas C. Isto seria um bocado de trabalho para uma grande biblioteca C, mas mesmo com uma minúscula sinto o desconforto de precisar recorrer a este tipo de gambiarra. O type system deveria ser expressivo o bastante para gerar bindings para estruturas e funções em C como se elas fossem objetos e métodos apropriados. Vou marcar isto para futuras melhorias comunitárias/fora-do-trabalho no Shiboken.

Vejamos um pedaço de código do arquivoepub_cpp_wrapper.h:

class EPub {
public:
...

~EPub() { epub_close(m_epub); }

static inline EPub*
open(const char* filename, int debug = 0) {
struct epub* book = epub_open(filename, debug);
if (book)
return new EPub(book);
return 0;
}

...
inline void dump() { epub_dump(m_epub); }

inline int
get_data(const char* name, char** data) {
return epub_get_data(m_epub, name, data);
}

...

private:
explicit EPub(struct epub* ptr) : m_epub(ptr) {}
EPub(const EPub& other) {}
EPub& operator=(const EPub& other) {}
struct epub* m_epub;
};

Note que todos os métodos são marcados como inline para fazer este envoltório o mais fino possível. (GCC, estou olhando pra você!)

Epub::open

A função epub_open se torna o método estático EPub::open que retornará um novo objeto EPub para o arquivo ePub dado pelo parâmetro filename, ou um null pointer se o arquivo for inválido ou não existir.
O construtor para esta classe foi feito privado de forma que o único modo de criar objetos EPub é via EPub::open, que nunca criará um objeto EPub inválido.

~Epub

Em C o responsável por liberar a estrutura epub é epub_close, mas não criarei um método EPub::close(), pois o equivalente C++ para ele é o destrutor da classe.

Um binding Python gerado para o que temos até agora seria mais ou menos assim:

import epub
book = epub.EPub.open('sample.epub')
title = book.get_metadata(epub.EPUB_TITLE)

Claro que não expliquei como isto seria gerado, que o módulo se chamaria epub, o que é epub.EPUB_TITLE, e como Python saberia o que fazer com unsigned char**, mas tenhamos paciência.

Movendo enums por aí

EPUB_TITLE é um valor vindo do enum epub_metadata, se ambos forem exportados para Python conforme estão, eles terão esta aparência:

import epub
epub.epub_metadata
epub.EPUB_TITLE

Assim fica bem feio e fuleiro. Já que epub_metadata é um enum relacionado ao objeto epub (como nos informa o prefixo epub_), será natural que ele seja movido para dentro da class EPub. No meu mundo de fantasia, a tag do type system que descreve um enum C++ para Python teria a opção de movê-lo para dentro de outro objeto, e também de ser renomeado. Algo desse tipo:

<enum-type name='epub_metadata'
rename='metatada'
move-into='EPub'
remove-enum-value-prefix='EPUB_' />

E aqui temos outro item para a lista de “por fazer” do Shiboken. Enquanto esta funcionalidade não é implementada, terei de fazê-lo manualmente.

class EPub {
public:
enum metadata {
ID = int(EPUB_ID),
TITLE = int(EPUB_TITLE),
CREATOR = int(EPUB_CREATOR),
CONTRIB = int(EPUB_CONTRIB),
SUBJECT = int(EPUB_SUBJECT),
PUBLISHER = int(EPUB_PUBLISHER),
DESCRIPTION = int(EPUB_DESCRIPTION),
DATE = int(EPUB_DATE),
TYPE = int(EPUB_TYPE),
FORMAT = int(EPUB_FORMAT),
SOURCE = int(EPUB_SOURCE),
LANG = int(EPUB_LANG),
RELATION = int(EPUB_RELATION),
COVERAGE = int(EPUB_COVERAGE),
RIGHTS = int(EPUB_RIGHTS),
META = int(EPUB_META)
};
...
inline unsigned char**
get_metadata(metadata type, int* size) {
return epub_get_metadata(m_epub,
epub_metadata(type),
size);
}
...
};

Os valores do enum epub_metadata foram convertidos para int para impedir o ApiExtractor de emitir toda sorte de warnings dizendo que ele não sabe quem são esses caras.

De qualquer modo, é terrível… ter esse gerador incrementado, e ter de escrever tudo isso… nãããão!

TIterator e EIterator

As estruturas C titerator e eiterator serão envolvidas pelas class C++ TIterator e EIterator, respectivamente, e como a classe EPub seus construtores serão privados.

class TIterator {
public:
enum type {
NAVMAP = int(TITERATOR_NAVMAP),
GUIDE = int(TITERATOR_GUIDE),
PAGES = int(TITERATOR_PAGES)
};
~TIterator() { epub_free_titerator(m_iter); }
inline bool isValid() {
return epub_tit_curr_valid(m_iter);
}
...
private:
friend class EPub;
explicit TIterator(struct titerator* iter)
: m_iter(iter) {}
struct titerator* m_iter;
};

Novas instâncias de TIterator e EIterator são criadas por métodos de EPub, por isso ela deve ser feita amiga (friend) das classes iteradoras.

class EPub {
public:
...
inline EIterator*
get_iterator(EIterator::type type, int opt = 0) {
struct eiterator* it = epub_get_iterator(m_epub, eiterator_type(type), opt);
if (it)
return new EIterator(it);
return 0;
}
inline TIterator*
get_titerator(TIterator::type type, int opt = 0) {
struct titerator* it = epub_get_titerator(m_epub, titerator_type(type), opt);
if (it)
return new TIterator(it);
return 0;
}
...
};

python-epub

Agora é hora de dizer ao gerador o quê entra e o quê será modificado nos bindings.

O cabeçalho global

O cabeçalho global é um arquivo que inclui todos os outros cabeçalhos da biblioteca que será analizada. No cabeçalho global o desenvolvedor de bindings pode também adicionar algumas cláusulas, como um #define que irá causar alguma condição de mudança nos cabeçalhos da biblioteca alvo, que irá afetar o binding gerado.

O arquivo epub_global.h que uso aqui é muito simples:

#ifndef EPUB_GLOBAL_H
#define EPUB_GLOBAL_H

#include <epub.h>
#include <epub_shared.h>
#include <epub_version.h>

#include "epub_cpp_wrappers.h"

// ApiExtractor reclamara' se
// encontrar apenas pre-definicoes.
struct titerator {};
struct eiterator {};

#endif

Como o comentário nos diz, ApiExtractor não gosta quando encontra pré-declarações sem definições. Escolhi adicionar estas definições falsas para struct titerator e struct eiterator. (Por alguma razão o gerador nada diz sobre struct epub.) Outra opção seria não usar estas definições falsas, mas adicionar uma linha ao arquivo type system dizendo ao gerador para ignorar avisos relativos à estas estruturas.

A descrição do Type System

Aqui segue um pedaço de código do arquivo typesystem_epub.xml.

<?xml version='1.0'?>
<typesystem package='epub'>
...
<rejection enum-name='epub_metadata' />
...
<object-type name='EPub'>
<enum-type name='metadata' />
...
</object-type>
</typesystem>

O enum epub_metadata não é exportado para Python (ao menos não diretamente) e para evitar que o gerador emita seus alertas, ele precisa ser explicitamente rejeitado; seu substituto C++ é adicionado depois dentro do object-type EPub. O mesmo acontece com os outros enums.

Na notação do type system object-type se refere aos objetos que são passados somente como ponteiros (como EPub, cujos construtor e operador de cópia são privados). Se, de outro modo, o objeto pode ser passado como valor, ele deve ser declarado como value-type, conforme nosso exemplo de Rectangle mencionado anteriormente.

O Protocolo de Iterador de Python

Em Python, se um objeto suporta o Protocolo de Iterador, poderei usar em comandos for, desta forma:

from epub import EPub, TIterator
book = EPub.open(self.epub_file)
for toc_it in book.get_titerator(TIterator.NAVMAP):
if not toc_it.isValid():
continue
print 'link : ' + toc_it.link()
print 'label: ' + toc_it.label()

Seguir o Protocolo de Iterador de Python consiste tão somente de um objeto implementar os métodos __iter__() e __next__().

Nota: o nome correto para o método é next() e não __next__(). Este é apenas um bug menor no gerador, que acabei de encontrar.

O XML para adicionar as funcionalidades do protocolo de iterador à classe TIterator será extenso, de forma que o partirei em duas partes, a primeira lidando com templates de código do type system.

Os templates do Type System

<?xml version='1.0'?>
<typesystem package='epub'>
...
<template name='iterator.__iter__'>
Py_INCREF(%PYSELF);
%PYARG_0 = %PYSELF;
</template>
<template name='iterator.__next__'>
if (%CPPSELF.next()) {
<insert-template name='iterator.__iter__' />
} else {
PyErr_SetNone(PyExc_StopIteration);
}
</template>
...

Os métodos de iterador para TIterator e EIterator terão exatamente a mesma implementação, então é esperto usar os templates do type system, e ter o código, e seus eventuais bugs, num único lugar.

O iterator.__iter__ método precisa apenas returnar o próprio objeto com seu contador de referências incrementado em um. iterator.__next__ chama o next() do objeto C++ subjacente (e também retorna a si próprio, e incrementa o refcounter), e sobe uma exceção Python StopIteration quando chega ao fim.

As variáveis do type system %PYSELF, %PYARG_0 e %CPPSELF são substituídas por valores dependentes do contexto onde são usados (e.g. as classes TIterator ou EIteration). Verifique a documentation para saber seus significados.

Adicionando os métodos de iteração

...
<object-type name='TIterator'>
...
<modify-function signature='next()' remove='all' />
<add-function signature='__iter__' return-type='PyObject*'>
<inject-code class='target' position='beginning'>
<insert-template name='iterator.__iter__' />
</inject-code>
</add-function>
<add-function signature='__next__' return-type='PyObject*'>
<inject-code class='target' position='beginning'>
<insert-template name='iterator.__next__' />
</inject-code>
</add-function>
</object-type>
...
</typesystem>

Primeiro o next() original do C++ é removido, então aqueles para o protocolo de iterador do Python são adicionados, usando a tag <insert-template/> para inserir o código personalizado definido anteriormente. A exatas mesmas linhas serão adicionadas à classe EIterator.

Só mais um pouco de gambiarras

Apenas um obstáculo permanece no caminho de ter iteradores Python apropriados. Quando o comando for de Python for usado para iterar sobre um objeto iterável, na primeira rodada ele chama o método __iter__ do objeto, e imediatamente após ele chama next, e continua chamando next para cada nova iteração.

O problema aqui é que o iterador C subjacente retorna um objeto levando conteúdo apropriado quando __iter__ é chamado, então a forma como a iteração do for Python funciona fará o primeiro item válido ser pulado. Uma gambiarra para este caso é usar uma flag no wrapper C++ que verificará se o iterador acabou de ser criado, de forma que ele não pulará para o iterador seguinte quando next for chamada pela primeira vez.

class TIterator {
public:
...
inline bool next() {
if (m_isFirst) {
m_isFirst = false;
return true;
}
return epub_tit_next(m_iter);
}
private:
friend class EPub;
explicit TIterator(struct titerator* iter)
: m_iter(iter), m_isFirst(true) {}
struct titerator* m_iter;
bool m_isFirst;
};

Pude ter esta liberdade porque TIterator é uma classe completamente sob meu (eu, o desenvolvedor do binding) controle. Se struct titerator fosse uma classe C++ desde o começo, esta solução não seria a melhor. Talvez se a libshiboken (a biblioteca de apoio usada por todos os bindings gerados pelo Shiboken) fornecesse uma classe iteradora base para lidar com essa diferença particular entre iteradores Python e C++. Ou talvez as classes geradas, quando identificadas como iteráveis pela presença dos métodos do protocolo de iteração adicionados pelo desenvolvedor do binding, poderiam ter tal funcionalidade. A última opção me parece a melhor, e esse é mais um item pra minha lista de melhorias futuras.

Conversões Personalizadas

Retornando valores unicode

Os métodos EIterator::curr() e EIterator::curr_url() returnam valores do tipo char*, que não tem um conversor (const char* é que tem), por isso escrevi um código específico para converter isto para unicode do Python.

<?xml version='1.0'?>
<typesystem package='epub'>
...
<template name='return_char_pointer'>
char* %0 = %CPPSELF.%FUNCTION_NAME();
if (%0) {
%PYARG_0 = PyUnicode_DecodeUTF8(%0, strlen(%0), "strict");
} else {
Py_INCREF(Py_None);
%PYARG_0 = Py_None;
}
</template>
...
<object-type name='EIterator'>
...
<modify-function signature='curr()'>
<inject-code class='target' position='beginning'>
<insert-template name='return_char_pointer' />
</inject-code>
</modify-function>
<modify-function signature='curr_url()'>
<inject-code class='target' position='beginning'>
<insert-template name='return_char_pointer' />
</inject-code>
</modify-function>
...
</object-type>
...
</typesystem>

Modificando a assinatura de um método

As assinaturas de alguns métodos C++ não podem ser automaticamente convertidas para código Python que faça sentido, então adicionei mais um pouco de código feito sob medida para tratar das situações caso a caso. Por exemplo, o método

unsigned char**
EPub::get_metadata(metadata type, int* size);

O argumento int* size recebe um ponteiro para um int, que conterá o tamanho da lista de strings unicode retornada como unsigned char**. Em Python ele meramente retornará uma lista de objetos unicode, e a chamada à get_metadata não precisa do argumento size.

Creio que a descrição do type system será o bastante para ver como o sistema de modificação funciona.

Baixando, compilando, etc.

Chega de explicações, agora vamos experimentar o código. Lembre-se que precisará também dos arquivos de desenvolvimento que mencionei muito tempo atrás

Clone a versão mais recente do repositório git:

git clone git://github.com/setanta/python-epub.git

ou baixe o tarball: python-epub.tar.bz2

No diretório do código fonte crie um diretório build e…

cd python-epub
mkdir build
cd build
cmake ..
make
ctest

O último comando merece uma conversa à respeito.

Testar, Testar, Testar

Quando trabalhando com desenvolvimento de bindings há uma miríade de coisas que podem dar errado, e muitas delas dão errado em completo silêncio. Tendo isto em mente, eu digo-lhe que ter testes de unidade torna a vida do desenvolvedor de bindings suportável.

Veja o diretório de testes para exemplos de como usar o bingind python-epub.

Para resultados detalhados dos testes, rode ctest com a opção -V (verboso).

Exemplo de UI (senão seria tedioso)

Mas a própria UI é bem tediosa, embora feita com o espetacular PySide, ela nem sequer mostra imagens. Por outro lado, com um pouco de código agora posso ver o conteúdo de um ebook ePub.

De dentro do diretório python-epub/build chame o visualizador de ePub dessa forma:

python ../simple-ui/bookviewer.py ../tests/beyond-the-wall-of-sleep.epub

Ele sempre espera um parâmetro com o caminho para um arquivo ePub, neste caso “Beyond the Wall of Sleep” de Lovecraft.

Screenshots:

Python bindings for libepub using Shiboken

2011-03-09T00:31:54+00:00

I have a Kindle, I like it very much, but unfortunately I can’t say the same about the format it used for books. Not that I have made a detailed study of the mobi format and came to the conclusion that it is technically inferior. No. The problem is that ePub is so much more popular, which mean more books, and more tools to play with. Calibre is awesome to convert between eBook formats, but I prefer the simplicity of downloading a book, copying it to the device and reading right away.

When my Kindle is not at hand, my replacement reader is a N900 with MeBook, one of my favorite apps – it looks for books (in ePub format) on Feedbooks, downloads to device and show them in a nice list with covers and all. Looking at MeBook source code I learned that it uses libepub to read the ePub eBooks, so I thought it would be interesting to make a Python binding to libepub. And here we are.

Ah, and one more thing before we start, I found a related Python project on github called libepub. Hadn’t checked it yet, but I mention it here for information’s sake.

Shiboken

Shiboken is the world famous tool used to generate the world famous PySide bindings (that happen to have reached 1.0 last week – yay!) It is one of the best tools around to generate Python bindings for C++ libraries. But that’s me talking – I work on it. But libepub is written in C, and even though Shiboken can generate bindings for a bunch of global functions and put them together in a Python module, that’s crappy. So I’ll have to make some preparations to make libepub appear beautiful in Python.

Pre-requisites: development files (i.e. the headers) for ApiExtractor, GeneratorRunner, Shiboken, and libepub. (For Debian/Ubuntu users this means: libapiextractor-dev, libgenrunner-dev, libshiboken-dev, and libepub-dev.) And the C++ compiler plus CMake, of course.

Remainder: ApiExtractor, GeneratorRunner and Shiboken are made with Qt (only the core libs, no ui for them), but the bindings generated do not depend on Qt at all. Except, obviously, if the library being wrapped already does.

libepub

First let’s have an overview of libepub. It has three structures used as opaque pointers:

// Contains information about the ePub file.
struct epub;
// Iterator object for the Table of Contents.
struct titerator;
// Iterator object for the book contents.
struct eiterator;

If you want to read the contents of an ePub file, call the function that will create an epub structure, iterate through its table of contents with a titerator, and then the contents themselves with an eiterator.

Most functions follow that “object oriented C” format seen in other libraries, with the first argument being a pointer to the structure that represents the “this” or “self” in OO languages. Examples:

void
epub_dump(struct epub* epub);

unsigned char**
epub_get_metadata(struct epub* epub,
enum epub_metadata type,
int* size);

int
epub_get_data(struct epub* epub,
const char* name,
char** data);

CMake

I’ll use CMake as the build system for the bindings because I feel comfortable with it – it is the same used in PySide and all the Shiboken generator tool chain. I’ll not give too much attention to this part of the process, just check the CMakeLists.txt files; more detailed explanation on the process of building a binding can be found in the PySide Binding Generation Tutorial. For really really basic information check PySide CMake Primer.

Handmade C++ Wrapper for a C library

To generate Python bindings for a C++ library one must write a XML description called type system, which will declare what must be exposed on Python land, and if any of this needs modification: global functions, classes, namespaces, enums. For example, if in C++ I have the class Rectangle, I would declare it in the type system this way:

<value-type name='Rectangle' />

All the methods belonging to Rectangle would be exposed to Python automatically. The same is not true for the C functions that representing the methods for the epub struct. Unfortunately there’s no way to tell the Shiboken generator that I want to have the epub structure and functions represented as a class with methods, so we have to make a thin C++ wrapper around the C structures. That would be a lot of work for a huge C library, but even with a tiny one I feel uncomfortable having to resort for this kind of hackery. The type system should be expressive enough to bind C structs and functions as if they were proper objects with methods. I’ll mark this for future community/out-of-work improvements on Shiboken.

Let’s see a snippet from epub_cpp_wrapper.h:

Notice that all methods were marked as inline to make this wrapper as thinner as possible. (GCC, I’m looking at you!)

Epub::open

The epub_open function becomes the static method EPub::open that will return a new EPub object for the ePub file given by filename parameter, or a null pointer if the file is invalid or doesn’t exist.
The constructor for this class was made private so the only way to create EPub objects is via EPub::open, that’ll never create an invalid EPub.

~Epub

In C the responsible for freeing the epub structure is epub_close, but I’ll not make it EPub::close() because the C++ equivalent for it is the class’ destructor.

A generated Python binding for what we have until now would look roughly like this:

import epub
book = epub.EPub.open('sample.epub')
title = book.get_metadata(epub.EPUB_TITLE)

Of course I didn’t explained how this would be generated, that the module would be called epub, what is epub.EPUB_TITLE, and how Python would know what to do with unsigned char**, but bear with me.

Moving enums around

EPUB_TITLE is a value from the epub_metadata enum, if exposed to Python as they are, they’ll look like this:

import epub
epub.epub_metadata
epub.EPUB_TITLE

Which is pretty ugly and lame. Since epub_metadata is an enum related to the epub object (as the epub_ prefix tells us), it would be natural that it was moved inside the EPub class. In my fantasy world, the type system tag that describes a C++ enum to Python would have the option to move it inside another object, and also to be renamed. Something along these lines:

<enum-type name='epub_metadata'
rename='metatada'
move-into='EPub'
remove-enum-value-prefix='EPUB_' />

And here I have another thing for a Shiboken TODO list. While this feature is not implemented, I’ll have to do it manually.

The epub_metadata enum values were cast to int to prevent the ApiExtractor to emitting a bunch of warnings saying that it cannot tell who these guys are.

Anyways, it’s so awful… to have a fancy generator, and having to write all this… noooo!

TIterator and EIterator

The C structures titerator and eiterator will be wrapped by the C++ classes TIterator and EIterator, respectively, and like the EPub class their constructors are private.

New instances of TIterator and EIterator are created by EPub methods, because of that it must be a friend of the iterator classes.

python-epub

Now it’s time to say to the generator which goes in and which must change in the bindings.

The global header

The global header is a file that includes all other headers of the library that will be analyzed. In the global header the binding developer may also add some tweaks, like a #define that will trigger some condition in the target library headers, that will affect the generated binding.

The epub_global.h that I use here is very simple:

#ifndef EPUB_GLOBAL_H
#define EPUB_GLOBAL_H

#include <epub.h>
#include <epub_shared.h>
#include <epub_version.h>

#include "epub_cpp_wrappers.h"

// ApiExtractor complains if it finds only pre-definitions.
struct titerator {};
struct eiterator {};

#endif

As the commentary tells us, ApiExtractor doesn’t like when it finds forward declarations without definitions. I choose to add these two bogus definitions for struct titerator and struct eiterator. (For some reason the generator said nothing about struct epub.) Other option would be not to add those bogus definitions, but add a line to the type system file telling the generator to ignore warnings relative to those structures.

The Type System description

Here follows a snippet from typesystem_epub.xml.

<?xml version='1.0'?>
<typesystem package='epub'>
...
<rejection enum-name='epub_metadata' />
...
<object-type name='EPub'>
<enum-type name='metadata' />
...
</object-type>
</typesystem>

The epub_metadata enum is not exported to Python (at least not as it is) and to avoid the generator emitting his warnings, it must be explicitly rejected; its C++ substitute is added afterwards inside the EPub object type. The same happens to the other enums.

In the type system notation object-type refers to objects that are passed around solely as pointers (like EPub, whose copy constructor and operator are private). If, otherwise, the object can be passed as value, it should be declared as an value-type, as our Rectangle example mentioned before.

Python’s Iterator Protocol

In Python, if an object supports the Iterator Protocol I can use it on for statements, like this:

Following the Python Iterator Protocol consists solely of an object implementing the methods __iter__() and __next__().

Note: the correct name for the method is next() and not __next__(). That's a minor bug in the generator that I just found.

The XML to add iterator protocol features into TIterator class will be lengthy, so I'll split it into two parts, the first dealing with type system code templates.

Type System templates

The iterator methods for TIterator and EIterator have exactly the same implementation, so it’ll be smart to use type system templates and have the code, and its eventual bugs, in a single place.

iterator.__iter__ method just need to return the object itself with its reference counter incremented by one. iterator.__next__ calls the underlying C++ object’s next() (it also returns itself, and increments the refcounter), and raises a Python StopIteration exception when it reaches the end.

The type system variables %PYSELF, %PYARG_0 and %CPPSELF are replaced by values dependent on the context where they are used (e.g. TIterator or EIteration classes). Check the documentation for their meaning·

Adding the iterator methods

First the original C++ next() is removed, then the ones for the Python iterator protocol are added, using <insert-template/> tag to insert the previously defined custom code. Exactly the same lines will be added to EIterator class.

Just one more bit of hackery

Only one obstacle remains on the way of having proper Python iterators. When Python’s for statement is used to iterate through an iterable object, in the first round it calls the object’s __iter__ method, and immediately after it calls next, and keeps calling next for each new iteration.

The problem here is that our underlying C iterator returns an object loaded with proper content when __iter__ is called, then the way that Python’s for iteration works will cause the first item to be bypassed. A workaround for this case is to use a flag on the C++ wrapper that checks if the iterator has just been created, so that it will not move forward when next is called on it for the first time.

I had this freedom because TIterator is a class completely under my (me, the binding developer) control. If struct titerator were a C++ class from the beginning that approach would not be the best. Perhaps libshiboken (the supporting library used by all Shiboken generated bindings) should provide a base iterator class to handle this particular difference between Python and C++ iterators. Or perhaps the generated class, when identified as an iterable by the presence of iterator protocol methods added by the binding developer, should have such provisions. The latter options seems best, and that’s one more item for my list of future improvements.

Custom Conversions

Returning unicode values

The EIterator::curr() methods EIterator::curr_url() returns values of char* type, which doesn’t have a converter (const char* does have), so I’ve written a custom piece of code to convert it to Python’s unicode.

Modifying a method’s signature

Some C++ method signatures couldn’t automatically be converted to meaningful Python code, so I added more custom code to handle the situation on a case by case basis. For example, the method

unsigned char**
EPub::get_metadata(metadata type, int* size);

The int* size argument receives a pointer to an int, which will contain the size of the list of unicode strings returned as unsigned char**. In Python it would merely return a list of unicode objects, and the call to get_metadata doesn’t need the size argument.

I believe the type system description is enough to see how the modification system works.

Downloading, building, etc.

Enough with the explanations, now let’s try the code. Remember that you’ll need also development files that I mentioned long time ago.

Clone the latest version from the git repository:

git clone git://github.com/setanta/python-epub.git

or download the tarball: python-epub.tar.bz2

Inside the source code directory create a build directory and …

cd python-epub
mkdir build
cd build
cmake ..
make
ctest

The last command deserves some talking about.

Testing, Testing, Testing

When working with binding development there’s a myriad of things that can go wrong, and a number of them go wrong in complete silence. With this in mind, I tell you that having unit tests makes the binding developer life bearable.

To see detailed results from the tests, run ctest with -V (verbose) option.

Check the tests directory for examples on how to use the python-epub bindings.

UI Example (or else it would be boring)

But the UI itself is very boring, although it was made with the amazing PySide I did it as simple as possible, it doesn’t even show images. On the other hand, with very little code I can now see what’s inside an ePub ebook.

From python-epub/build directory call the ePub viewer like this:

python ../simple-ui/bookviewer.py ../tests/beyond-the-wall-of-sleep.epub

It always expects a parameter with the path to an ePub file, in this case “Beyond the Wall of Sleep” by Lovecraft.

Screenshots:

Férias 2011! Destino: Europa

2011-03-05T13:25:14+00:00

Depois de quase 2 anos sem férias e sem nenhuma viagem de “grande porte”, finalmente é chegada a hora de um merecido descanso do trabalho e de ir pra algum lugar ainda desconhecido, desbravar novas fronteiras.

O destino original que haviamos planejado ainda no ano passado era a Ásia, mais precisamente Índia e China com potencial de chegar até o Japão. Ir pra esses destinos por conta própria e com pouco tempo exige um consideravel esforço de planejamento e logística (vistos, idioma, grandes distâncias e altos custos em alguns lugares), então após alguns estudos, decidimos optar por um destino mais tranquilo e com melhor relação custo-benefício nesses aspectos: Europa.

Serão 35 dias no total (valeu Carnaval!), chegando por Paris e voltando por Milão. Com excessão das passagens de ida e volta, o roteiro está quase todo em aberto, pois como estamos em baixa temporada (final do inverno por lá), os riscos de problemas com hospedagem e transporte são mínimos.

O roteiro planejado, por enquanto, é esse:

Paris;
Londres;
Amsterdam e Rotterdam;
Berlin;
Moscow (ida e volta à Berlin);
Cidades diversas nos países do Leste Europeu (Polônia, República Checa, Eslovênia, Hungria?);
Viena;
Munique;
Zurique e região dos Alpes;
De Veneza até Roma;
Milão.

No mapa:

Visualizar Viagem Europa 2011 em um mapa maior

(suficiente pra cumprir o objetivo de 2 novos países em 2011) ;-)

Provavelmente não haverá tempo pra todos os destinos e o plano é alugar um carro em alguns desses trajetos, o que nos dará a oportunidade de conhecer cidades e vilas menores. Também existe a possibilidade de embarcarmos em voos baratos como os de EUR 7 da Ryan Air pra chegar em cidades mais remotas, ou mesmo mudar completamente a parte final da viagem.

Como sempre, será uma viagem sem exageros nos custos, com apoio de couchsurfers ao longo do caminho e muitas fotos. Pequenos relatos e fotos mais descompromissadas devem aparecer nos perfis do twitter @adebr e @tudocasa (Viviane) e em meu facebook.

Espero dessa vez pré-selecionar as fotos no caminho pra evitar o problema que tive com a viagem de 2009 à Patagônia, que não teve suas fotos publicadas até hoje (shame on me!). :-P

Em tempo, muito obrigado a todos os que nos ajudaram com dicas de roteiro e aos couchsurfers que nos ajudarão ainda mais durante o trajeto. :-)

Posts possivelmente relacionados:

Link Permanente | 2 commentários
Post tags: europa, viagem

FOSDEM talk

2011-02-22T11:23:12+00:00

I will upload the slides soon.

[Update] Slides are up here at slideshare.net

Mandriva 2010 : rodando sua aplicação como administrador(root)

2011-02-21T18:16:37+00:00

Imagine que você desenvolveu uma aplicação que precisa de permissão de root. Agora você quer que o Mandriva chame sua aplicação como usuário administrador(root).

0 – Minha aplicação simples é um Hello world

echo -e '#include \nint main(){printf("hello mandriva world\\n");}' > hello.c
gcc hello.c -o hello

1 – Chamar o console-helper ao invés de chamar sua aplicação:

su - root
cd /usr/bin
ln -s /usb/bin/console-helper hello

2 – Criar arquivo PAM /etc/pam.d/hello

#%PAM-1.0
auth            include         config-util
account         include         config-util
session         include         config-util

3 – Criar arquivo com PATH em /etc/security/console.apps/hello

USER=root
PROGRAM=/home/alecrim/hello
SESSION=true
FALLBACK=true

N810 + HD 1.5 TB + SAMBA = media server

2011-02-05T13:27:07+00:00

Aproveitando estes dias em que estou em casa de folga. Resolvi mexer um pouco com os equipamentos por aqui. O N810 andava meio solitário, depois que passei a utilizar mais o Nokia5800 para acessar a internet.

Outro problema é o fato de não gostar de ficar ligando os cabos do meu HD externo no netbook para acessar músicas e filmes.

Decidi compartilhar os arquivos meu HD externo via SMB usando meu N810. As principais passos seguem abaixo:

1 – N810 + HD

Gostaria de lembrar que o N810 possui um limite de energia que pode suprir para o equipamento plugado. Estou usando um HD externo com alimentação de energia. Instalei o aplicativo “usbmode” ou ative o modo “host” executando o comando abaixo:
echo host > /sys/devices/platform/musb_hdrc/mode

2 – Instalar Samba

sudo gainroot
apt-get install samba

3 – Configurar samba

cat /etc/passwd | mksmbpasswd > /etc/samba/smbpasswd
chmod 600 /etc/samba/smbpasswd
smbpasswd user
vi /etc/samba/smb.conf # download smb.conf HERE
sudo /etc/init.d/samba restart

Depois disto, use Windows Explorer para acessar seus arquivos. Você pode executar videos e músicas diretamente.

kdeplasma-addons is on git too

2011-02-01T20:15:04+00:00

Today we finally converted kdeplasma-addons to git The rules itself were written some time ago and we waited for the conversion of kdelibs and kdebase. Thanks to eean I found a last minute problem on the rules and today we fixed that!

Picture by The Rocketeer

You can find kdeplasma-addons on https://projects.kde.org/projects/kde/kdeplasma-addons and you can easily clone the repo using:

git clone kde:kdeplasma-addons

Assuming that you did the trick below in your ~/.gitconfig file:

[url "git://anongit.kde.org/"]
insteadOf = kde:
[url "ssh://git@git.kde.org/"]
pushInsteadOf = kde:

I have been working with git for almost four years now and I used a lot of tools to create projects and help with visualizing repositories. With ReviewBoard and RedMine all integrated, the commit mails, integration with BKO and other features (a lot of them were already present with svn) I can say that KDE’s git infrastructure is one of the most complete and professional that I’ve ever seen. It’s really very “PRO” and I would love to have any of our sysadmins working on my IT department. Guys, you really rock! (besides doing an amazing work).

I think that it’s fair also to thank KO that sponsored Ian to work and do the conversions of kdelibs and kdebase. This was not an easy job and it’s really a pain to do the conversion *right*. Of course we may find some rough edges right now as we still need to get used to new workflows and new tools but IMHO we will overcome that and soon we will feel the benefits of git

Beat Maker – call for testers

2011-01-18T02:00:40+00:00

Hello all!

I promised this new release for the end of the last year, but I delayed it a bit due some changes in my professional and personal life.

Anyway, basically this release is about bug fixing and performance improvement. It’s using less power now, and playing faster.

If you want to try this version, you can get the package here.

And bugs reports are always welcome, and needed ;)

ps.: I’m still trying to upload it to OVI, lets see…

Small update for ‘share’ dataengine

2011-01-08T18:37:52+00:00

Invest in sharing! by Toban Black

Following the awesome work done by our sysadmins, I implemented a backend for the share data engine that supports the use of KDE’s official pastebin service: http://paste.kde.org .

This way people using trunk will already have this support upstream and people using earlier versions (which includes 4.6 !) can also use the script provided by Andrea Scarpino thanks to the brand new Get Hot New Stuff support that I integrated into the Pastebin applet for 4.6

Today I also signed up to Flattr, in order to test this micropayment service that sounds like a great idea to donate small amounts to people that do great work and create awesome content. I must say that I signed up after wanting to Flattr the work done by Lydia (aka Nightrose) and Tom Albers (aka toma).

Of course I don’t expect to earn a lot of money this way, but It’s awesome to be able to help some great workers and also add the possibility of earning a little bit of money, specially in the year of your wedding

Install Kubuntu Mobile on the N900

2011-01-07T20:05:19+00:00

Some time ago I wrote a post about a project we were working on called Ubuntu Liquid. Well since then a lot has happened.The Bossa Conference came to Manaus with a great plasma mobile talk, the project changed its name to Kubuntu Mobile, the awesome KDE and Kubuntu communities became involved and we managed to finally get a Technology Preview release out of the door for Ubuntu Maverick!.

I remember promising some instructions on how to install the release onto a device. There are already some canonical instructions available on the Kubuntu wiki to get started so I will updated this with the things I discovered as I was playing around with this install.

The N900 has a Texas Instruments OMAP3 microprocessor with an ARM Cortex-A8 core. Unlike all of the Nokia models which preceded it - 770, N800 and N810 - the N900 has full phone functionality (quad-band GSM and 3G UMTS/HSDPA). It is quite interesting therefore to get Ubuntu running on it. Be aware though that Kubuntu Mobile is *not* yet ready to replace Maemo on an N900. Unless of course you really know what you are doing or even better you really know what you are doing and want to help out - either upstream or with the actual distro itself. Our current target is to have Kubuntu Mobile fully working on the N900 in time for the 11.04 Natty release.

Requirements

An N900 with Maemo5 pr1.3 installed
A MicroSD 8GB, at least, class 6 or better - a lesser class will run but then Kubuntu Mobile runs very slowly.

First make a directory and download the image.

ian@lawrence:/media/80GB$ mkdir Liquid;cd Liquid
ian@lawrence:/media/80GB/Liquid$ wget -c http://cdimage.ubuntu.com/kubuntu-mobile/ports/daily-preinstalled/current/maverick-preinstalled-mobile-armel+omap.img.gz

The above link is not working, it seems the image is not building on cdimage - whilst we debug what is happening please try this one

http://cdimage.ubuntu.com/kubuntu-mobile/ports/releases/10.10/release/

Partition the MicroSD card. I used gparted (apt-get install gparted). The three partitions on the card are

An ext3 partition (using the most part of the MicroSD)
A linux swap partition
A small VFAT partition

Next extract the kubuntu-mobile image and dd it to the ext3 partition - mine is mounted on /dev/sdd1. You need to be root to do this as sudo will not work.

ian@lawrence:/media/80GB/Liquid$ gunzip maverick-preinstalled-mobile-armel+omap.img.gz
ian@lawrence:/media/80GB/Liquid$ sudo dd bs=4096 if=maverick-preinstalled-mobile-armel+omap.raw of=/dev/sdd1

then check that everything is ok.

root@lawrence:/media/80GB/Liquid# sudo fsck.ext3 -cy /dev/sdd1

e2fsck 1.41.12 (17-May-2010)
Checking for bad blocks (read-only test):  14.18% done, 0:15 elapsed

I did this check twice (just to make sure). Now mount the MicroSD card (just unplug it).Install qemu-arm-static if it is not already on your machine and then copy it from the system /usr/bin to the partition /usr/bin

ian@lawrence:/media/80GB/Liquid$ sudo apt-get install qemu-arm-static                          
ian@lawrence:/media/80GB/Liquid$ sudo cp /usr/bin/qemu-arm-static /media/a6c5c4e9-555c-4565-ba1d-ceea8d5a953f/usr/bin/

Make sure that any data buffered in memory is written out

ian@lawrence:/media/80GB/Liquid$ sync

Download the latest meego image

ian@lawrence:/media/80GB/Liquid$ wget -c http://repo.meego.com/MeeGo/builds/trunk/1.1.80.11.20101221.1/handset/images/meego-handset-armv7l-n900/meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw.bz2

unzip the raw image

ian@lawrence:/media/80GB/Liquid$ bzip2 -d meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw.bz2

next run fdisk (notice the three partitions in this image)

ian@lawrence:/media/80GB/Liquid$ sudo fdisk -l -u meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw


meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw1               1     3515625     1757812+  83  Linux
Partition 1 has different physical/logical endings:
     phys=(1023, 3, 32) logical=(27465, 3, 10)
meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw2         3516416     3891199      187392   83  Linux
Partition 2 has different physical/logical beginnings (non-Linux?):
     phys=(1023, 3, 32) logical=(27472, 0, 1)
Partition 2 has different physical/logical endings:
     phys=(1023, 3, 32) logical=(30399, 3, 32)
meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw3         3891200     4016127       62464   83  Linux
Partition 3 has different physical/logical beginnings (non-Linux?):
     phys=(1023, 3, 32) logical=(30400, 0, 1)
Partition 3 has different physical/logical endings:
     phys=(1023, 3, 32) logical=(31375, 3, 32)

now mount the image

ian@lawrence:/media/80GB/Liquid$ sudo mount -o loop,offset=512 -t auto meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw /mnt/

copy the kernel modules and firmware to the first partition of the MicroSD card

ian@lawrence:/media/80GB/Liquid$ sudo cp -a /mnt/lib/modules/2.6.35.3-13.10-n900/ /media/a6c5c4e9-555c-4565-ba1d-ceea8d5a953f/lib/modules/ -a
ian@lawrence:/media/80GB/Liquid$ sudo cp /mnt/lib/firmware/* /media/a6c5c4e9-555c-4565-ba1d-ceea8d5a953f/lib/firmware/

now we need to mount the third partition of the .raw meego image (which contains the bootable kernel - vmlinuz) and copy that to the vfat partition of the MicroSD card. To do this we need to work out where the third partition starts. The end of the second partition is

meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw2         3516416     3891199      187392   83  Linux

so we need to multiply 3891199 by 512 to find the offset

3891199*512=1992294400

make a temporary mount point then

ian@lawrence:/media/80GB/Liquid$ sudo mkdir /media/teste1
ian@lawrence:/media/80GB/Liquid$ sudo mount -o loop,offset=1992294400 -t auto meego-handset-armv7l-n900-1.1.80.11.20101221.1-mmcblk0p.raw /media/teste1/
ian@lawrence:/media/80GB/Liquid$ cp /media/teste1/* /media/B68E-53AB

run sync

ian@lawrence:/media/80GB/Liquid$ sync

and then unmount

ian@lawrence:/media/80GB/Liquid$ sudo umount /mnt
ian@lawrence:/media/80GB/Liquid$ sudo umount /media/teste1

Enter the chroot on the partition

ian@lawrence:/media/80GB/Liquid$ sudo chroot /media/a6c5c4e9-555c-4565-ba1d-ceea8d5a953f/
root@lawrence:/#

Make sure that the chroot can get a network

root@lawrence:/# echo "nameserver 8.8.8.8" >> /etc/resolv.conf

exit the chroot

root@lawrence:/home# exit

Check out some meego configurations from the git repositories. These are needed for the essential-kubuntu-mobile.sh script below

ian@lawrence:/media/80GB/Liquid$ mkdir meego;cd meego
ian@lawrence:/media/80GB/Liquid/meego$ git clone git://gitorious.org/meego-device-adaptation/n900_nokia-n900-configs.git
ian@lawrence:/media/80GB/Liquid/meego$ git clone git://gitorious.org/meego-device-adaptation/n900_udev-rules-nokia-n900.git
ian@lawrence:/media/80GB/Liquid/meego$ cd ..

We have a script to make the next part of the Kubuntu Mobile install easier - I put it on my server for convenience

ian@lawrence:/media/80GB/Liquid$ wget -c http://ianlawrence.info/downloads/liquid/essential-kubuntu-mobile.sh

and make it executable

ian@lawrence:/media/80GB/Liquid$ chmod +x essential-kubuntu-mobile.sh

change the variables in the script

MPATH="/media/a6c5c4e9-555c-4565-ba1d-ceea8d5a953f"
GITPATH="/media/80GB/Liquid/meego/"

to the correct ones for your install. Also change the user name ian

chroot $MPATH adduser ian

for something you will remember.Next run the script.

ian@lawrence:/media/80GB/Liquid$ sudo ./essential-kubuntu-mobile.sh

and answer the questions for the new user. That is everything completed on the MicroSD card and we can now try to boot it!.
First check that the software on the N900 is the correct version (pr1.3) on the device going to Settings -> About product. The version number should read 20.2010.36-2.002. Next check that Extras-devel is enabled in the Application Manager.

Navigate to the application menu (tap the title bar)
Select ‘Application catalogs’
Enter a catalog name of ‘Maemo extras-devel’
Enter a web address of http://repository.maemo.org/extras-devel
Enter a distribution of ‘fremantle’
Enter components of ‘free non-free’
Select ‘Save’

after the repositories are updated open an X Terminal on the device and type

~ $ sudo gainroot

which gives a root shell on the device. Then install uboot-pr13 using apt

/home/user # apt-get install uboot-pr13

uboot-pr13 installs u-boot to the kernel area, along with PR1.3 kernel and it means we can dual boot a device. Verify it's installed by restarting your N900. A penguin should show up at startup and U-boot will be mentioned, let it time out and boot into Maemo. Now take the MicroSD card we prepared and put it into the N900 and reboot. It takes a long time to boot but the end result is worth it
not because it really works too well yet but because of what it might be one day.
If you want to help #kubuntu-mobile on irc.freenode.net.

My blog in 2010

2011-01-02T13:44:01+00:00

The stats helper monkeys at WordPress.com mulled over how this blog did in 2010, and here’s a high level summary of its overall blog health:

The Blog-Health-o-Meter™ reads Wow.

Crunchy numbers

A helper monkey made this abstract painting, inspired by your stats.

About 3 million people visit the Taj Mahal every year. This blog was viewed about 30,000 times in 2010. If it were the Taj Mahal, it would take about 4 days for that many people to see it.

In 2010, there were 8 new posts, growing the total archive of this blog to 27 posts.

The busiest day of the year was August 27th with 328 views. The most popular post that day was Running PySide applications on Qt Simulator.

Where did they come from?

The top referring sites in 2010 were developer.symbian.org, maemo.org, labs.trolltech.com, labs.qt.nokia.com, and thezeroth.net.

Some visitors came searching, mostly for undefined reference to `vtable for, undefined reference to vtable, qt symbian linux, undefined reference to vtable for, and undefined reference to `vtable.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

Running PySide applications on Qt Simulator August 2010
2 comments

Installing Qt for Symbian SDK 4.6.2 on Linux February 2010
44 comments and 1 Like on WordPress.com,

“undefined reference to `vtable for …’ errors” in Qt derived classes April 2009
8 comments

Installing Qt for Symbian SDK 4.6.1 on Linux January 2010
43 comments

Running Qt for S60 SDK on Linux July 2009
12 comments

Retrospectiva 2010, planos pra 2011

2010-12-31T03:00:03+00:00

Esse foi um ano de pouca atividade nesse blog, mas eu não poderia deixar de fazer meu já tradicional (desde 2006) post de retrospectiva e de planos pro próximo ano.

2010 foi um ano sem grandes acontecimentos pra mim mas grandes mudanças pra Viviane. Vamos ao resumo (como esse blog é meu, ela só vai ganhar um item):

Viviane concluiu o curso de Design de Interiores, expôs na CasaCor-PE 2010 – ganhou até prêmio – e está bem resolvida na nova profissão até agora. Ela também tirou carteira de motorista, criou um blog, virou fã do google-reader e deu passos largos na sua evolução do uso de tecnologia – pra grande orgulho de seu marido nerd; :-)
Mesmo morando no litoral, fomos apenas uma vez pra praia;
Não tirei férias;
Comprei mais livros do que li;
Viajei a trabalho pra vários lugares interessantes: Manaus, Boston, Nova York, Pittsburgh, Oslo e Munique;
Comprei um Wii, com Guitar Hero (guitarra e bateria), Wii fit e outros jogos;
Fiz o upgrade do meu desktop;
Joguei bastante StarCraft2;
Recebemos visitas de minha sogra e de dois casais de couchsurfers;
No twitter eu postei 331 mensagens (240 status, 80 replies e 11 RTs);

Dos 7 objetivos traçados ao final de 2009, dois falharam vergonhosamente e um foi cancelado:

~~Fazer pelo menos um passeio em Maragogi – AL.~~ OK: passamos um ótimo feriado de Natal em Japaratinga (cidade na região);
Ir de carro até Petrolina, no interior de Pernambuco (734km de Recife). CANCELADO: desisti da viagem de carnaval após me convencerem de que a estrada era insegura e que não valia a pena. Chegar ao cânion do “Velho Chico” via Aracaju parece ser bem mais negócio;
~~Visitar um país que ainda não conheça~~. OK: Noruega em setembro (viagem a trabalho);
Publicar os relatos e fotos da viagem à Patagônia. NOT OK (vergonhoso, nem as fotos eu publiquei);
~~Ter um celular com bom acesso à Internet e teclado qwerty~~. OK: usei um n900 por vários meses e agora estou com um N8;
Começar a estudar um novo idioma. NOT OK (vergonhoso);
~~Fazer um upgrade do meu velho desktop, deixando-o pronto pra StarCraft II que vem aí~~. OK: atualizei o micro e SC2 virou o vício das horas vagas :-).

Pra 2011 tracei objetivos um pouco mais ambiciosos. Em ordem arbitrária:

Visitar dois países que eu ainda não conheça (também conhecido como “tirar férias e viajar pra uma terra desconhecida”);
Atualizar a seção de fotos do site (Patagônia, Recife, Oslo, Nova York, Boston e férias 2011);
Visitar nossos familiares e amigos no sul do Brasil (no mínimo Rio Grande – RS e Umuarama – PR. Curitiba será uma tentativa);
Começar a estudar um novo idioma, junto com a Viviane;
Estudar (formalmente ou não), pois evoluí menos do que esperava em 2010 (também pudera: Wii, Modern Warfare 1 e 2, StarCraft 2, etc);
Melhorar minha atividade nas “redes sociais”, reforçar antigas amizades;
Comprar algum tipo de tablet, preferivelmente um que sirva como ebook-reader;

Filho? Hmmm, isso fica como possível surpresa pra 2011/2012, vamos ver… :-)

Um ótimo 2011 a todos!

Posts possivelmente relacionados:

Link Permanente | 5 commentários
Post tags: retrospectiva

mpp.py v1.2

2010-12-18T03:32:51+00:00

O mpp.py é um pequeno utilitário que criei pra manter em sync minha página de fotos (estática) com meus álbuns gerenciados localmente no Picasa.

A última versão (v1.1) foi lançada em julho de 2008, então resolvi que era hora de lançar uma atualização. Não há grandes mudanças na versão 1.2, apenas a evolução do script conforme bugs e necessidades foram surgindo ao longo desses últimos 2 anos.

Se você é um dos 2 ou 3 usuários do mpp.py, a atualização é fortemente recomendada. ;-)

Mais detalhes na página do projeto.

Posts possivelmente relacionados:

Link Permanente | Nenhum comentário
Post tags: code, computação, python

The bad side of “The Cloud”

2010-12-15T12:45:21+00:00

The Cloud - by web@kstp.com

Since some time ago I started to worry that some “vital” information for me was on the “The Cloud” and that most of the service providers didn’t provide a way to retrieve my stuff or a support line.

I started to worry also about privacy for the first time in my life: what if companies suddenly becomes evil? Hmm. That could be bad. The “big players” are able to know everything about me: the email I read, the news I read, who are my friends, my family, my pictures….and much more! They could relate all this information to know what I like, what I dislike and so on.

Of course there are benefits. By knowing me more, they can offer better services that could be refined search, special advertisement or even make it easier to find that friend from kinder garden that I’ve never met after I was 4 (?)…

But what is the problem if they turn evil or decide that I do not deserve anymore these goods?

Some months ago I started to “migrate” at least some of my important stuff to open source and “controlled by me” services. I’m now sharing a server with one of my friends where I have my own email service for instance. I also contributed some patches to Akregator to let me share my news with my friends. I started to just use identi.ca and let Twitter “replicate” that, so my friends from Twitter get my thoughts. But in worst case I can just install Status.net on my server and voilà. I’m also looking forward ownCloud.

Yesterday and today I had the proof that I’m not (completely) paranoid (and trust me, I’m one of the last ones to be paranoid about subjects ).

Starting from yesterday: after getting an invitation to try Diaspora (thanks Lydia!), and linking my twitter account there I discovered that my Twitter account was “suspended”. Ow great. I was supposed to get an email when this happens and there was nothing on my inbox neither on spam. I tried filling a support request and I always get the “Could not perform the task. Wait a few minutes” message.

I don’t know how but I finally received an automatic email from one of this support tickets that actually managed to be sent (all the time I tried I received an error…). I followed all the guidelines and answered the email asking for my account back. Tom pointed out that twitter had some security issues…but it has been already 24 hours that they disabled my account without sending even an email. If it wasn’t Diaspora I would never discover that it was suspended.

Today, while reading my morning news, I discover that Richard had a problem with Google and can’t solve that. He tried email, forums and everything else he could. Ah, great! He even has an Android phone that is pretty useless without a Google account. I’m sorry Rich

“The Cloud” is awesome, isn’t it? That’s why we need projects like StatusNet, Diaspora, ownCloud and Open Desktop (UPDATE: thanks to the ones that pointed out that open desktop isn’t actually open source).

Roadmapping at the University of Nairobi, Kenya

2010-12-13T20:56:24+00:00

Nokia Data Gathering is released on a six monthly cycle. At the beginning of a new development cycle, community developers, NGO's and interested users gather to help shape and scope the next release of NDG (3.04).

The road mapping meetings are open to the public, but they are not conferences, exhibitions or other audience-oriented events. Rather, they provide an opportunity for software developers -- who usually collaborate online -- and technically orientated system integrators to work together in person on specific tasks related to the planning of the next Nokia Data Gathering release.

We were really fortunate for 3.04 that the University of Nairobi allowed us to hold the meeting at the Computer Science Department and that so many passionate staff, students and users came along and made the meeting so special. I think we all (well I am sure I did anyway) learned a powerful lesson about software development.

Build features which people want, need and will actually use rather than what we think people want.

We came with many great shiny new ideas for data gathering but it was simplicity, accessibility and security which were requested.

When that new feature I wanted to build (to scratch my own itch in all reality) falls over and a field worker in Liberia for example cannot send a Birth Registration Form no-one recognizes that child as a member of society able to receive medical treatment, go to school or find legal work. I can sleep well hungry, penniless, lonely or cold but I cannot sleep well knowing that is because of me.

Maybe itch scratching is an easy trap to fall into after working for so long on free software projects but it nearly bit me here and I am eternally grateful to Africa and to our community for the heads up and guidance. A big shout also must go out to Peter Wagacha and the rest of the team at the University for giving us this chance to learn and finally special congratulations and new mobile phone go to Bryann for the winning proposal for the release name. The next release will be called Brave Batian and it promises greatness!

The peak of Batian (17,057 feet) is the highest peak on Mount Kenya, the second highest mountain in Africa. Mount Kenya has a girth of about 95 miles at 8,000 feet, from which it rises boldly to its restricted summit zone. Mount Kenya is the source of the name of the Republic of Kenya.

PySide 1.0.0~beta1 binaries released for Ubuntu

2010-12-07T15:36:28+00:00

Didier ‘OdyX’ Raboud once again borrowed his great Debian packaging/integration skills to the PySide project, and created packages for the latest Ubuntu releases (including the development one, codenamed “natty”). They are available on the official repository. See the download instructions page for more details. See also the original announcement.

MeeGo Conference and the Mobile Sprint

2010-11-22T14:41:46+00:00

Then November became a very busy month.

After the Qt Dev Days San Francisco, I went quickly to Natal to present a talk about Qt and KDE on mobile devices. It’s time to say thank you for the ENSL organizers – As always, I am late with my posts…

So, last week we went to Dublin, for the MeeGo Conference 2010. As more people already posted, it was a really nice event. The good surprise was the limit of the number of Intel and Nokia people, leaving space for the growing community meet – more than a thousand people attended, very well accommodated in the place chosen (the conference rooms in the Aviva Stadium) with a good work of the organization which managed to keep things working nicely.

Although the short time of the presentations, it was good to have a whole ideaof how the project is being conduced, and it looks promising. Unfortunately I left Dublin on Wednesday morning, so I lost the last day which was reserved for the ‘unconference‘ sections and the football match, but I managed to go to the Guinness Storehouse in Tuesday night, a really good choice for the conference after hours.

With the Lenovo ideapad received from the MeeGo Conference guys (thanks! :-)) in my backpack, I traveled to Berlin for the KDE Mobile Sprint, kindly hosted by KDAB in its office.

I must say, we had fun with the new devices. :-)
During the sprint, interesting discussions about MeeGo, new opportunities, QML and Qt-components. Some of the guys dedicated their time to KDE packaging for MeeGo while in parallel other ones worked in QML based widgets for plasma, tested how some applications work on the ideapad’s touchscreen, and tested plasma-mobile and plasma-tablet shells on it. The results of this sprint are being listed in this wiki page.

The first steps :-)

Check the videos in Marco’s and Artur’s posts about the sprint. Also, Till Adam showing Kontact Mobile on MeeGo.

Of course there is more work to do, but considering how things worked without special attention to this device (and for MeeGo), we can expect good news in the future.

And here a screenshot of the gallery to test the Plasma QML widgets, with a FlashingLabel, some BusyWidgets and a PushButton. It’s just the beginning.

I know, the gallery is, let's say, weird... :-P

KDE Mobile Sprint and MeeGo

2010-11-21T17:09:46+00:00

Yep, I didn’t blog about MeeGo Conference yet. But come on, a lot happened during the last few days I barely had time to sleep really well (those that know me can tell histories about my sleep-walking and sleep-talking hehe).

However, just to keep everybody updated before I do a full post or read an article on the dot here it is a simple video that means a lot!

http://www.youtube.com/watch?v=UKdLCGCTu8w

Basically we put Plasma mobile to run on top of MeeGo and thanks to a lot of Marco’s work we already supported screen rotation! Besides the “fail” that drivers don’t properly report that the screen is being rotated on this device, pressing some keys we can make the view rotate and then comes the magic

Of course we also put the Plasma netbook to run on the device but the mobile one was really nice to play with our hands Keep your eyes on the Planet as I think more people have news to share

More about the sprint and the conference after the break

“If you’re going to San Francisco…”

2010-11-02T11:44:57+00:00

“…You’re gonna meet some gentle people there”

This part of the Scott Mackenzie’s famous song is definitely true. I’m in San Francisco since last Friday and I’m enjoying the city.

The true reason for this trip is the Qt Developer Days, which started yesterday with the training sections and the demo area, where I could see different kind of applications, products and ideas using Qt or created to ease the development with Qt.

It’s just a short post, in a few minutes there will be the first keynote and I have to go downstairs. :-)

This is my first DevDays, special thanks to the Qt Developer Network guys who decided to bring some of the contributors!

Open Innovation Africa Summit

2010-10-29T13:22:07+00:00

This is a nice initiative that Nokia is spearheading with Capgemini and The World Bank to explore and foster the innovation eco-system in Africa.

It's called the Open Innovation Africa Summit and it's happening the week of November 29th 2010 in Nairobi, Kenya!

The summit aims to promote creation of new innovation services and collaboration models, which ensure continuous alignment between different players of the innovation ecosystem as well as to embed end-user driven co-creation and open innovation as critical elements to African innovation systems.

They've launched a great ideation platform as part of it that revolves around the four main streams for the event:

Ecosystem for Innovation
Emerging Market Business Models
Mobile Services Revolution
Human Capital - Education for All

You can check out the website and find more information here: www.innovateafrique.com

We're launching official communication about the event next week but I wanted to let readers of this blog know about this extraordinary initiative and to get your help providing insights and ideas (there are also 8 seats dedicated to the top contributors and readers here could for sure contribute greatly at the event itself, so I thought I'd give you all a heads up :)

The road mapping meeting for the 3.04 Nokia Data Gathering release takes place directly after this event at the School Of Computing And Informatics, University of Nairobi.

Sharing articles using Akregator

2010-10-22T17:07:47+00:00

A month ago I integrated into Akregator the “share” feature that uses Plasma’s microblog service to help you to share news with your friends using the microblog services (identi.ca and twitter). The good thing about using identi.ca is that all your data belong to you and you can easily replicate your posts to twitter too. Another place where identi.ca is better than twitter is that it provides RSS feeds for all kind of information.

You may be asking yourself: “why the heck is this useful?”. The answer is: everytime you share some article on Akregator it publishes the title of the article, the link to the article and put’s a tag “#share”. This way you can use the tag feed to retrieve the news that your friends are sharing: just add the RSS feed to your feed reader and voilà This provides a feature that looks like the one that Google Reader provides, but in completely open environment!

If you are interested in reading my shares, just add this to your reader: http://identi.ca/morpheuz/tag/share/rss .

I’m on vacations so it has been hard to keep doing any development as I’m busy traveling with my fiance but I can post about some stuff that I’ve been developing before my vacations!

See you!

Using Nokia N8 to make SIP calls over 3G and WiFI

2010-10-17T20:39:18+00:00

Hi there,

I’ve been playing with the new Nokia N8 (Symbianˆ3) and was able to use it as a softphone to make and receive VoIP calls using my default SIP provider. As the setup is not that straightforward, I’m sharing the steps here.

Installing SIP VoIP Settings

The first non-obvious thing is that the N8, as well as other S60 v5 and v3 devices like 5800 and N85, doesn’t come with the settings applications pre-installed. Without that, the built-in SIP settings is pretty much useless for our purpose.

So, rush to Forum Nokia and get / install the settings application. The new version is compatible with Symbianˆ3 devices so it fits nicely the Nokia N8.

Creating a SIP profile

To actually use your VoIP provider account you will need to setup SIP proxies, user name, password, codecs, etc. Nokia has split this rigmarole of settings into two separate things which it calls SIP Settings and VoIP services. So you’ll need to create both. Let’s start with the former.

Start by opening the Menu and going into:

Settings > Connectivity > Admin Settings > Net Settings > Advanced VoIP settings > SIP settings

If the above settings page is not available, then check the previous step.

Now create a new profile by going into Options > New SIP profile

Here you’ll need to fill in the connection details as the SIP proxy address and login information. In my case I use Inphonex and they provide detailed information on how to do that. Your experience may vary but your provider should require similar settings, basically is to set Proxy and Registrar servers.

Creating VoIP service

Once the previous is done, go up one level and then go into VoIP services

Create a new service Options > New service and point it to the SIP profile you just created.

[Optional] Enabling use of VoIP over 3G

If you only intent to use WiFi to make VoIP calls, then skip this step, otherwise click the name of the VoIP service you just created and go into Profile settings.

Now search one configuration flag called “AWCDMA” (Allow WCDMA), change that to On.

Testing

Find more about how to make cheap calls to india.

Go to your phonebook, there should be a new tab on the top. Between Contacts and Groups, a tab with the globe and a phone. Click it and you should be able to click a Sign-in option (if it’s not signed-in already). To confirm that, check whether this phone+world icon is shown at the top-right corner of the status-bar, close to the Bluetooth and WiFi icons (see Image).

Now open the dialer, dial something and click Options -> Call -> Your_SIP_Service_name

Should be that

Hopefully this post if useful for you, comments are always appreciated. Enjoy!

Updates

2010-10-17T05:06:56+00:00

Looooong time since my last post. Before writing about new things, an overview of what happened since June:

In August, I went to the Belo Horizonte Free Software Festival (in Betim =), where I presented an introductory talk about F/OSS and KDE. It was a nice opportunity to explain some basic concepts to a beginner but very interested public. Thanks e.V. for the support and to the FSLBH organizers!
I moved to another apartment (second time this year).
I did not go to Akademy =(
Our interns developed a simple, but nice, comics-reader as part of their studies to learn Qt. The source code is here and there is a Maemo 5 package here.
Two of our cute demos from the last year grew up and became applications. The updated sources are available here and here. Kudos to the guys who made it possible!
I’ve been working in the development of kdepim-mobile and, in parallel, I’m following the development of Qt-Components. It is interesting because kdepim-mobile is trying to to use QML as much as possible for the UI, what provides interesting feedback to Qt-Components.
Patches for the widgets explorer. Since I started using a vertical panel on the right, I found some bugs and things to improve.
I’m enjoying the Qt Developer Network – More about it in a future post :-)
Some airport and flight minutes were dedicated to do a first translation of Enzyme and Commit-digest to pt_BR. As I am not a translator, it’s time to request help for the pt_BR translation team =)

Someone said a few weeks ago that a good post must have a picture. Here is a picture of the Municipal Park and the ”Hippie Fair“, in Belo Horizonte:

Bluetooth Low Energy on BlueZ

2010-10-15T21:53:20+00:00

If you are searching for technology details of Bluetooth 4.0 or if you need the answer for “why Low Energy”: wrong post! The SPEC is public, anyone can open an account in the Bluetooth SIG and download the adopted specs.

My objective is to provide an initial directions of how Bluetooth Low Energy(BLE) will work on BlueZ. The implementation is still under development, but we already have a clear picture of how we will support BLE and GATT/ATT.

In a couple of years it will be common to find dual mode Bluetooth capable devices: supporting Basic Rate and Low Energy. BlueZ will run on dual mode devices: devices that doesn’t have strict power consumption constraints. The most common cases for BlueZ devices will be the BLE Central role: managing and collecting data from Peripherals(coin cell devices).

For this project, there are two major pieces: BLE controller abstraction and the attribute protocol.

Our goal is to hide BLE technology details from the applications. BlueZ will expose the same interface for device discovery operations, meaning that the applications doesn’t need to know the hardware capabilities/features. BlueZ will use the same abstraction(D-Bus signals/messages) to report found devices and services. Internally, BlueZ will manage the interleaved scanning/inquiry and the characteristics discovery.

ATT(Attribute Protocol) will be the core of the future profiles over BLE, ATT is a very simple protocol to exchange characteristics. It can be considered transport agnostic. We decided to implement GATT/ATT first over BR/EDR due the BLE hardware availability, extend to BLE is just a minor surgery in the BlueZ code.

For more information access BlueZ source tree: doc/attribute-api.txt

Beat Maker: The drum loop maker written with Qt

2010-10-14T23:37:11+00:00

Beat Maker is my “pet project” with Allyson Soares at INdT.

It is, basically, a drum loop emulator to be used by musicians during practicing sessions.

You just need to select the samples, define a BPM value and listen to the rhythm ;)

If you can’t wait for the official release at Ovi Store, you can try the beta version for n900 devices.

Remember: it’s a beta version of an open source software. The code can be found linked to my gitorious account.

The technical point of view:

I’m a little bit disappointed with phonon. After a long discussion I’ve realized that phonon could not be used on Beat Maker.

At this time I’m using an approach suggested by Adriano Rezende: play the sound using pulseaudio’s API. I know, it’s not portable. But hey, my target is N900 devices and it worked pretty well at the time.
However, it doesn’t scale. So, now, I’m working on a kind of “in-app-mixer”, which should solve this problem.

There is another problem, related to QTimer. Qt can’t guarantee the timing between the beats using QTimer events. Especially when you generate mouse events. Anyway, the mixer controller loop should solve this as well.

Big thanks to Adriano for the tips, and Allyson who made the excellent UI design.

I hope you enjoy it.
Suggestions are welcome =)

ps.: youtube video bellow

Qt 4.7.0 for Symbian on Linux (now with Qt Creator support!)

2010-10-11T16:08:16+00:00

It’s been some time since my last update on the Qt for Symbian Linux installer. My colleague Bruno Abinader did a great job in the meantime, by releasing his own modified “all-in-one” script that installed gnupoc, Qt, Qt Mobility and Smart Installer .

From now on, I’ll follow Bruno’s idea and provide a single script that installs everything you need for Qt for Symbian development on Linux. This version will install just gnupoc and Qt, but next ones should support Qt Mobility and Smart Installer as well. I also temporarily disabled support for S60 3.1 SDK, so for now there is only S60 5.0 SDK support.

Some of you might have noticed that the official Qt 4.7.0 documentation has some experimental installation instructions for Linux. Unfortunately, it requires compiling Qt from sources, which might take long time and currently requires the non-free ARM RVCT compiler. The instructions on this post are my attempt on creating a usable setup in a user-friendly way.

So, enough explanations, let’s go to the instructions!

Preparation

Download all required files to a single directory (e.g. “~/downloads”):

gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2 (11MB): CodeSourcery’s ARM toolchain for Symbian
gnupoc-package-1.17.tar.gz (8.6 MB): tools and patches to run Symbian SDK on Linux
qt-symbian-opensource-4.7.0-s60.exe (262 MB): Qt for Open Source C++ development on Symbian
S60_5th_Edition_SDK_v1_0_en.zip (622MB): S60 SDK for Symbian OS (click on the “Download S60 and Symbian SDKs” button)
s60_open_c_cpp_plug_in_v1_7_en.zip (31 MB): Open C/C++ Plug-ins (under “Plug-ins for the Symbian SDKs” section)
qt_for_symbian_4.7.0_linux_installer_v4.sh: Unofficial Qt for Symbian installer for Linux

For building the native tools from gnupoc, you will need:

the GCC C/C++ compilers
development files for zlib
development files for openssl

On Ubuntu, you can install these using the following command:

sudo apt-get install build-essential zlib1g-dev libssl-dev

Installation

Install everything using a single command:

./qt_for_symbian_4.7.0_linux_installer_v4.sh \ <download-dir> \ <install-dir>

Replace <download-dir> with the location of all files downloaded in previous section (e.g. “~/downloads”), and <install-dir> with the destination directory (e.g. “~/gnupoc”). Note that both directories must have absolute paths.

If installation was successful, you should see the message “Installation has finished!” followed by some instructions. Follow those to setup Qt Creator and/or command line.

Device setup

Install Qt on the phone, by copying and installing the <install-dir>/qt_4.7.0/qt_installer.sis package. This single SIS file has all necessary dependencies for running Qt applications.

Additionally, if you plan to use Qt Creator, I suggest installing s60_5_0_app_trk_3_2_7.sisx. It will allow quickly testing your application directly on the device through bluetooth. Also make sure your desktop and phone are paired, then run these commands:

sdptool browse local | grep -q "Service Name: Serial Port" \ || sdptool add SP sudo rfcomm listen rfcomm0

The first command makes sure the Serial Port service is only added once, and the second one creates the /dev/rfcomm0 device. You should see output like:

Serial Port service registered Waiting for connection on channel 1

On the phone, open App TRK (It should be under the “RnD Tools” directory). It will show “Status: Not connected”. Go to Options -> Settings, and make sure “Connection” is set to “Bluetooth”. Next, go to Options -> Connect and select your desktop from the Bluetooth devices shown. On the phone, you should see:

Status: Connected BT Dev Name: <your_computer_name> BT Port number: 1

While on your desktop console:

... Connection from XX:XX:XX:XX:XX:XX to /dev/rfcomm0 Press CTRL-C for hangup

Now, when you click “Run” on Qt Creator, you should see something like this on its “Console Window”:

Executable file: /home/lizardo/gnupoc/sdk_5.0/epoc32/release/$(PLATFORM)/$(TARGET)/animatedtiles.exe Package: 117288 2010-10-11T11:43:23 /home/lizardo/NokiaQtSDK/Examples/4.6/animation/animatedtiles/animatedtiles.sis Deploying application to 'Bluetooth device (/dev/rfcomm0)'... Copying installation file... Installing application... Starting application... Application running with pid 1134.

And the application should install and open directly on your phone Enjoy!

And there I go: Qt Dev Days Munich!

2010-10-10T20:30:51+00:00

Hey! From this Monday to Thursday I’ll be at Unterschleissheim, Germany, attending the Qt Dev Days Munich. Meeting all Qt hackers again will be awesome, as always, but the best thing about this trip will be meeting my INdT’s fellows! ;)

So, if you are aroud:

(*not sure where I took this picture from =/)

Cheers!

Partindo para novos desafios – Obrigado BRISA

2010-10-05T18:49:41+00:00

Depois das constantes quedas da LGE, tivemos baixas significas na BRISA Tecnologia. Agora, estou mudando novamente de empresa. Obrigado BRISA pela oportunidade e desafios que tivemos neste período de 4 meses.

Dentro de alguns dias, inicio uma nova busca por desafios no Instituto Eldorado, que possui excelentes parceiros como Motorola, DELL, HP e Positivo. Estou bem ansioso para ver os projetos que terei por lá.

Espero poder trazer excelentes novidades nas próximas semanas! \o/

Styles for Qt and KDE: A new approach

2010-10-01T18:32:46+00:00

At this year’s Akademy I’ve presented a talk that summarizes a new way of styling C++ widgets in Qt and KDE. Now checkout the companion paper with in deep explanations of the ideas proposed there.

Get it HERE

PandaBoard.org and Early Adopter Program

2010-09-30T00:12:20+00:00

Today it was finally released the new PandaBoard website, showing everything you wanted to know about the new community oriented OMAP 4 board.

If you are already used with BeagleBoard, Panda should be similar in some way, but now deploying the latest OMAP 4 SoC and tons of new stuff.

What you can find at the PandaBoard:
– Dual Core ARM Cortex™ A9 powered by OMAP4430
– 1GB LPDDR2 SDRAM
– PowerVR SGX 2D/3D Graphic Accelerator
– WLAN, BT and FM by WL1271
– DVI-D and HDMI support
– 2x USB Host + Ethernet by LAN 9514
– Mini USB with OTG support
– SD/MMC
– JTAG
– RS-232 UART
– LCD and Generic Expansion and more

Software Support:

Another good thing is that much of the software support is already available at omapzoom, like Kernel, X-Loader and U-Boot. Upstream kernel is still missing some patches, but there’s a lot of work going on linux-omap, so expect at least basic support from upstream soon. For bootloader you can already use U-Boot from upstream, as Sakoman did an awesome work doing the Pandaboard and OMAP 4 support.

Early Adopter Program:

While PandaBoard is still not out for general public you can already participate at the Early Adopter Program and luckly get a board for free (and first than everyone else)! All you need to do is go to http://www.omappedia.org/wiki/PandaBoard_Early_Adopter_Program and propose a cool open source project that could take use of it. The board is really small and powerful, think about running Ubuntu, MeeGo or any other distro and getting 3D support, 1080p video decode and more! Lots of ideas, for sure.

If you’re interested don’t waste your time and join the still small PandaBoard community, joining the mailing list and IRC channel #pandaboard at FreeNode.

Happy hacking!