Tag Archives: mobile

QtQuick, the Plasma way

Software

Those days, working hard on bugfixing and polishing for the 4.5 SC release, however caught by the impatience of testing the new shiny features that will be in Qt 4.7, I gave a try on a weird crossover you’ll hear more and more about in the future: QtQuick+Plasma

Now, in playground there are some Plasma bindings for QML almost since the declarative module was announced, but only lately, as it matures for Qt 4.7 inclusion has been possible to expand them to make possible to have a quite good integration between the two technologies.

Work started in February at Tokamak 4, were thanks to the beginning of this integration was possible tohave a working prototype of Plasma Mobile in a single week, starting from zero.

As a test bed for expanding the bindings where something more was still needed, I did a prototype of a plasmoid with the interface a bit more complex than usual, that could be easily used as a full screen application in a mobile environment. Since there is another set of KDE applications for wich a mobile version is being written (all the KDE pim apps) i decided to just shamelessy copy from it, since is one where the visual design has been already done.

The video below shows a simple prototype of a mail client for a mobile device: the basic interaction works, even tough the data is dummy, being a simple demo.

OGG version

It’s written completely in QML, without a single C++ line of code, and can work both as a fullscreen mobile application as shown there as well as a normal Plasma widget in your desktop

A really important charateristic of this (and of the other future Plasma widgets written it this tecnique) is that exept the item view, it only uses Plasma widgets (widgets as in components like buttons, text fields etc) and animations, this will give some interesting benefits:

  • Consistent look and feel, either across your desktop or in various apps of your mobile device. Even across different kind of devices, like mobile, netbook and desktop, while having a radically different look to fit the different form factors, the applications will bring a certain level of familiarity and “unity”
  • The widgets have an consistent and rich api, that can be accessed from both Javascript and C++ pieces of code (or whatever language bindings), when a “QML only” approach is not enough.
  • The Plasma animations are written in Javascript themselves: they can be “themed” to achieve different feelings on different devices without having to touch code in the applications/plasmoids themselves. In the future will also be possible to do important things like turning them off globally when the battery level is critical or things like that.
  • great separation of data and visualization achieved trough dataenines: is possible to completely change the ui without ever touching the logic of the program or how the data is fetched, and write the visualization completely in a declarative way, while not being limited in any way in how the dataengine plugin is written.

As said before, to recap it will be possile to write plasmoids completely in QML, or include pieces of QML ui in any kind of plasmoid is already possible to write, being C++, Python, Ruby or even our already existing Javascript bindings.

This demo in the video isn’t going to be a real world application, but it is a really good showcase of what Plasma can offer in this regard, and how is easy to write a pretty rich mobile application that can be adapted across a wide range of devices. So in the future there will be many plasmoids that will rougly follow those lines.

Bits and pieces are still missing, some work remains to do, but for KDE SC 4.6 there will be in libplasma something that will be usable by everybody to build some awesome stuff.

Plasma Netbook 4.5

Software

So, it was pretty a long time since the last time I blogged about the KDE Plasma Netbook project… what’s going on on that? you wanna videos?, you’ll get videos 🙂

This doesn’t mean it’s stopped. Au contraire my friends, since 4.4, many of its parts were rethought and redesigned. Some of those changes are quite visible at a UI level, some other are more under the hood, but contribute to give to it a more “finished” look and feel to it.

Alongside KDE SC 4.4 the first version of the Netbook Shell was released, and while it was a really big achievement for us it was still at a really early stage: it had to be released (early and often, they say :)) but now things begin to really get serious.

We made a step back and looked at it, asked ourselves where we want it to go and what purpose it will have to serve (in brief: developer sprints are very, very useful :p)

When we started the project Netbooks were a certain defined thing: underpowered device (low price, weight and power consumption), compact size (high portability) and a very targeted use case: they are mostly Internet devices, or a platform to run very simple applications, so more of a secondary machine for casual use rather that a proper laptop.

In the meantime they have changed, they are more near to a laptop, with bigger (but not actually big) screens and almost normal hard drives.

So, they really have changed so much? yes and no. We can’t afford for this reason to be “less careful” to issues like screen size or power consumption, because despite how it could look, they still continue to be quite different beasts compared to laptops.

Computing power issues aren’t going to go away anytime soon, and even if tomorrow morning netbooks will have a resolution of 1920×1080 or 3 times more, 10 inches are going to remain 10 inches: your eyes don’t zoom.

So, what we will see in this area in the future?

  • More diversification: bigger screen with Atom and smaller screens with ARM (will it actually happen? I hope so)
  • More original devices: clamshell notebook-like as usual, opposed to tablet form factors: so two totally different types of user interfaces will be needed, right? Well, the world could be more complex (and interesting) that that.
  • So, there will be more kinds of devices, some of them will be addressed by Plasma Netbook, some of them by Plasma Mobile.

So, after thinking about it for a moment the natural process is to pass from the tough that this was not as different of our every day computing as we thought to the certainly that the challenges that will be faced will be way more than ever thought.

So, let’s not be so far-fetched and let’s see what are the new shiny things that will ship in KDE Plasma Netbook Shell 4.5.

Faster. Several optimizations have been done on the shell itself and on the Search and Launch activity, (alongside the continuous optimization work it is being done in Qt, especially on the QGraphicsView features we put on a pretty tough stress test:)) Now the general usage and feeling should be a lot snappier and responsive.

Search and Launch. It uses a different way to fetch the data used in the menus, so they should be a lot more accurate now.

Moreover, extensive drag and drop support has been added. This makes it more intuitive to use and more friendly on a touch screen device. On the video below you can see it used on a normal netbook, on the usual 800MHz little tablet with Moblin and on a bigger tablet with an 1GHz Via processor (note here the video driver is the plain old vesa but it’s running pretty decently anyways). 3 completely different devices, same UI, of which some elements are starting to translate very well across all three, some of them still not, and here is where the extremely modular architecture of Plasma comes to its full power. just replace the little elements that interaction wise are device specific.

Last but not least you can see there also that many of the layout and behavior rough edges that were previously in the icon view have been solved.

OGG version

Newspaper. The main information hub of Plasma-netbook, shown in the video below. As all the Plasma “flickable” scroll areas, uses brand new code (by our very best graphics ninja, actually 😉 to handle the touch and the flicking in a much better way.

Now,to improve both the looks and the usability of it, the widgets appear perfectly aligned in a 2×2 grid (it’s still possible to have as many columns and rows as we want by the way). By interacting on a widget, it will expand to take up to the whole screen height, so offering a “maximized” view of it, that reflects the concept that now your attention is on that particular one (so, trascuring for a while the other ones, albeit still reachable)

the page can behave like this or all the widgets can be “maximized” like before, eliminating all the internal scrolling areas leaving only the big external one. this will probably be the preferred behavior on touch screens.

OGG version

Other than that, there is the quite important addition of javascript support I talked about in the last entry: it will make personalization (by distributors and in the future directly by users as well) very very easy.

KDE on MeeGo

Software

This entry will show off a new cute thing, while also being a pretty shameless call for help 🙂

Last couple of days i was playing with the MeeGo sdk, it’s still a very young system but is really interesting (probably also exactly -because- it’s so young)

After installing the meego atom image on a netbook (by basically copying everything by hand, don’t think there is already an automated installation procedure yet?) and after updating all the packages I noticed at the current stage there indeed -is- a working X11 on it, so the subsequent step was quite obvious of course 🙂

The setup of the main SDK on the development machine as described on their wiki is really straightforward, so having a complete chrooted build environment is a matter of a moment.

Then i started to build a trunk version of KDE… almost all packages -required- for a build are already available (and recent enough 🙂 in the standard MeeGo repository, so I did a pretty basic build (with optional stuff kept to the minimum, will be important to decide carefully what would or would not be included in a build for that, since is targeting mostly low power mobile devices)

The result can be seen in this video (of course with Plasma Netbook shell, since we are on a particular environment like that)

As a side note on this video, is also show some new features of the Plasma Netbook shell in the upcoming KDE SC 4.5, but this is another story 🙂 (will do screencasts on those shortly)

OGG version

It can be seen that the boot is really really fast, and the performance is quite good too. It is significantly faster than on an older X11 on the same machine, however there are still some graphics glitches (not present on OpenSuse on the same machine) But I’m confident all of this will be gone on a new release of video drivers/X11/Qt (we have been here some times already after all :))

So, moral of the story, this shows KDE libraries and apps can be build really quickly there, they can work really well and that is the platform where some of our new projects can really shine, like the Netbook, the Mobile and the Mediacenter shells. Now think about for instance remote widgets between a mediacenter and a phone, or a phone and a netbook, just to name some of our technologies that would really come to full potential when having them on different devices

So, if you know how to do -good quality- packages, (that honestly, is really -not- my expertise :)), maybe already involved in the MeeGo packaging effort, some help will be really really appreciated, it would be really cool to set up a repository that people can use to quickly install a whole KDE stack on a (at the moment still text mode only) MeeGo install

On screen keyboard

Software

In in an old screencast for Plasma Mobile, you seen a demonstration of an on-screen keyboard, it was a working proof of concept, but the interactin was still a bit wonky…

I love when those things happen: The autor of that plasmoid, Bjorn Ruberg (hats off) seen it and wanted to do something about… the result is a completely reworked widget, (that will be shipped with SC 4.5) now it’s faster, it has a way smaller memory footprint and more important is way more accurate now. typing on it has became quite fast.

In this little video it’s shown the keyboard widget working in an external little app that takes over a part of the screen (designed for small mobile devices) on the small Jax10 and on a larger old via-based tablet.


OGG version

Get the bleeding

Software

Today, as Aaron and Frederik said, we just launched a really cool thing: periodically updated images of a reference distribution for KDE Plasma Netbook. It’s done with the openSUSE build service and is based on opensuse; however it’s quite customized with our artwork and settings, so the general feeling of the distribution is exactly what the name suggests: a reference.

Search and Launch

It is (or, will be since we’re at very early stages of development) how we envision a complete system that boots straight into the Plasma netbook shell, and to be also a way to quickly test the really really bleeding edge development version without messing up your own system 😉

It is also very easy to customize the build on the openSUSE build service to make your own branch, so remixes and sperimentations of new ideas is really welcome 🙂

Here you can find the usb stick image, and here some useful documentation on Techbase.

A vertical Plasma

Software

Two little extra videos linked to the previous post, this is always plasma-netbook and plasma-mobile running on the JAX10 with Moblin, this time with the screen rotated to vertical.

It is a bit of an hack since the device doesn’t have an accelerometer and the touchscreen needs to be recalibrate every time the screen rotates, but is neat as a proof of concept, because neither Plasma Netbook or Plasma Mobile were never designed thinking about vertical screens, but in both cases, always keeping in mind we are at early prototype stage, they work quite well.

Something to be noted, fullscreen plasmoids tends to look a bit better on a vertical screen rather than an horizontal one, and our on screen keyboard works already quite well, even tough it’ll need to show less keys when in a tiny screen

OGG version


OGG version

A mobile Tokamak

Software

Suse officesSo another Tokamak went by, it is always sad to leave from this amazing group of people, but there are also two good things on that: 1) you know you will see them soon. 2) you know a really impressing amount of work has been done.

One of the big focus points of this meeting was how we tackle the new mobile devices, from a Plasma and more general KDE perspective.

It was a bit strange for me, because it didn’t involve as much coding as usual, but a lot of work on getting the KDE build working well on a particular mobile device.

We had three Compal JAX10 devices loaned from Intel with installed an image of the Moblin environment, version 2.1. While both software and hardware wise they are still a bit far from a “commercial” release, but that’s exactly what makes them interesting.

Everybody hackingThis is a device with capabilities pretty near to a netbook, however it has a totally different set of limitations and requirements.

Here we don’t have a normal keyboard, but just a little slideout one, and we have to remember that some of the devices of this class won’t have a keyboard at all. Of course there is no mouse/touchpad as well, this means all cursor input is done via touch screen.

With a touch screen some interesting things happen: precision becomes really poor, so we need bigger targets. Moving the cursor and pressing the “mouse button” happens at the same time, so you can just click: anything that relies on mouse hover becomes immediately useless. Screen edges, the most reachable area with a mouse, becomes the less convenient one to use

Anyways, it was an interesting experiment: how far we can get, in a single week, starting from the bare libplasma to do an user interface for a device like that?

In the end we ended up not with one interface but with two: I adapted the Plasma Netbook interface to some of the quirks typical of a touch screen (a lot work still has to be done) and I obtained something that works quite well as a general launcher for touchscreen based tablets, that still can use an (adapted of course) version of desktop applications mixed with the “newspaper” concept (where “turning pages” will become a really natural concept) and Plasma Widgets that will run as a full screen application.

Here is a short video of the Search and Launch usage (a rough prototype had already been shown some days before Tokamak, now it’s starting to work really well): it shows the horizontal scrolling of the results when the little touchscreen is landscape and the drag and drop of items around: really important there since the little actions on mouse over don’t work there: also for deleting them a particular drop target with a little trashcan appears. Another important point is that now on a touchscreen a drag (being of the results view, of an icon around) begins with an enormous treshold compared to a desktop/netbook: in this way it adapts to the really low precision that a finger has on a touchscreen.

OGG version

And the last concept brings us to the design of the other user interface: on a really small mobile device, such a phone, it will become simply impossible to use the regular full applications (logic and ui will have to be decoupled). Many Plasma widgets have a quite small UI, so as far as real screen estate is concerned they can work suprisingly well on small screens, they also make extensive use of touchscreen friendly concepts, like flickable scrolling views and drag and drop (even some basic multitouch support, like pinch zooming, if ony X could :p)

Some widgets, like the Opendesktop plasmoid work really well already, with just some fixes to be done here and there.

Another advantage using the Plasma widget library is that being based on QGraphicsview, they are on top the same framework of Maemo 5 and Maemo 6 ui, allowing coherence and interoperability.

On devices like a phone, we will probably also need a different primary user interface, since the size will be even smaller, not only in terms of resolution but most important, in terms of real size (the JAX10 and the N900 are both 800×480, but the N900 has more dpi, so a smaller screen)

Another reason we can want a different ui for a real phone are the main use cases, for instance here i want to be able to reach the actual phone dialer with as less gestures as possible, and the target use case is even more “casual” for function that are not related to telephony itself.

We had some design sessions about the use cases, interaction paradigm and code design of it, then Nuno produced some really beautiful graphics and mockups. Artur and Alexis sat down and implemented a proper full featured plasma shell over that mockup and got it working in an impressive short amount of time. As I said, I couldn’t code much on that (but I plan to fix it in the next days;) because my job was mostly getting everything working on the JAX devices, so long sessions of building, patching, rebuilding testing, fixing and rebuilding again. Artur has a really interesting post on it too, as well as Alexis.

At the end of the week we produced a video that once released (will take some time to edit) will explain what we did and our plans in detail.

As a preview, here are two short videos that show what we got at the moment.

OGG version

OGG version

Another Plasma netbook screencast

Software

Another screencast of yours truly: this shows the Plasma netbook shell running on a bog standard Asus EeePc 1005Ha.

It can be seen the new neat animations of the search and launch interface when results are loaded. What’s neat is that it seems to run quite well on this pretty basic hardware and animations are just as smooth as they should be 🙂

OGG version

Kubuntu Netbook Remix 9.10

BlaBla

So today Kubuntu 9.10 was released. I wish to the whole team my congratulations for the release 😀

I want to sped two words about a new additin in the Ubuntu fleet: Kubuntu Netbook Remix. This particular version of Kubuntu ships (and uses as the default user interface) an early preview of what will be the Plasma Netbook project.

We (as both upstream KDE people and Kubuntu people) wanted to quickly put something out of the door, to give people an easy way to test it, and make it a bit more known before the final release, and requiring people to run trunk is not really reasonable, while a livecd poses a way lower entry barrier.

While you are testing it, please keep in mind is software in a really early stage of development.Kubuntu Karmic Koala of course uses KDE 4.3, because it’s what is out at the moment :). Since some months ago the Netbook project uses some important new features that will be in the Plasma library for KDE 4.4, so the version shipped in Kubuntu is a snapshot a bit older that what is in svn now (plus some backports of more recent fixes), that’s why it looks pretty different to the last screencasts i did.

So keep in mind that the “real deal” on Kubuntu will come just with 10.04 (or as soon as KDE 4.4 packages will be released), but I’m confident that what is shipped now is something already quite fun to use, and gives an idea how it will be, so try it, have fun 🙂

Trying the netbook project made easy

Software

Since two days there is a new module in systemsettings: workspace under the Desktop category.
workspace options
Here is possible to switch between the Plasma desktop shell and the netbook shell. the switch will be done on the fly (no need to restart KDE) and it will be remembered the next KDE start.

Plasma desktop will close, Plasma netbook will start and some different settings on KWin will be applied: windows will start as maximized and there will be no border for maximized windows.

The other section is Dashboard: is now possible to configure from here if you want the dashboard with the same content of your desktop or if you want it to show an independent set of widgets.

In the same way, in the Multiple desktops section, is now possible to decide if you want a different plasma activity for each desktop, so the quite hidden config dialog reachable from the zoom interface for those two options has been removed.