Overview

This is an awfully dry post; dry due to the sheer logistic nature of it. This functionality exists and is quite straight forwards to stumble upon. This blog exists in order to draw your attention to it and hopefully minimize the stumble time.

You have a device:

1) Running an ssh server
2) With gdbserver

You also have:

1) A functional tool chain for the target (Code Sourcery is the traditional goto)
2) A Qt build for your target
3) A Linux box you are deploying from (My convenience, instructions should be readily repurposeable for Mac based developers)
4) Qt Creator (Qt Creator 2.4.0 (as shipped with the QtSDK) was used at the time of filming/documenting this process)

Qt Creator has various merits which basically speak for themselves.

Integrated documentation
Convenient remote visual debugging/profiling
Convenient (single click) deployment

You grow accustomed to this functionality if you target any of the officially/unofficially supported targets tightly integrated into Creator in its various distributions. (Official SDK, Necessitas, Meego SDK). It would be lovely if it were more commonly perceived as a generic end to end solution for deployment to generic Linux targets, and it is readily achievable if you avoid a couple of snags.

Initial configuration

Launch Creator
Menu -> Tools -> Options

Build & Run -> Qt Versions

Add your Raspberry PI Qt build: /opt/dev/qt-qpa-5-rasp-pi/bin/qmake

Creator indicates “Qt version 5.0.0 for Desktop”, this can be safely ignored.

Build & Run -> Tool Chains

Add your cross compiler: /opt/toolchains/arm-2010q1/bin/arm-none-linux-gnueabi-gcc

in my case. Adjust the ABI in the unlikely event it is incorrect.

Linux Devices -> Device Configurations

Add configuration with correct ssh details, deploy a public key and establish this works.

Per project configuration

1) Open an existing Qt application (example suffices)
2) Select a desktop build

Once this is done:

Projects -> Targets -> Build

Specify your target’s Qt version
Specify the toolchain from the drop down below

Projects -> Targets -> Run

Deployment

Method: Deploy to Remote Linux Host
Device Configuration: Select your “Linux Device” added in the Device Configurations step above

Run

Run Configuration: foo (on Remote Device)
Arguments: -platform eglfs

This should suffice, you should now be able to deploy, run and debug applications on the Raspberry PI (or any other similarly capable Linux based target)

A screen grab demonstrating the logistics is available here

A video where I talk through the steps is also available for those willing to weather my accent

Caveats

1) If you select a QtQuick UI project from the project wizard you will not be able to deploy to the target (will be grayed out). If you select a Qt Quick application you will get a QDeclarativeView based viewer/launch pad. If you want to dabble with Qt 5 (who doesn’t) at present, one has to ride to war with one’s own QQuickView based runtime/viewer (read: pony)

2) Qt must already be deployed on the target. We clearly handle this for our own devices, but when you are winging it as documented here, Qt has to have been (manually) installed to the configured prefix. (Needless to say, it is best to sanity check the Qt install prior to attempting IDE based deployment).

The post Raspberry PI: A case study in deploying Qt apps to generic Linux devices appeared first on Qt Blog.

Cross compiling Qt for particular devices/BSPs can be frustrating when operating from first principles and we are trying to improve the existing configure/qmake build infrastructure in Qt 5, as well as the associated documentation, in order to ease this burden. We are approaching the problem from 2 angles:

• General cross compilation support
• Direct target support

The general cross compilation support is being improved by:

• Reworking the pkg-config logic
• Introducing the -device flag to configure
• Introducing the -sysroot flag to configure

The supported targets are documented here:

http://wiki.qt-project.org/Devices

and as you can see in the Raspberry Pi documentation, we have reduced compilation for this target down to:

./configure -prefix <your prefix> -release
  -device linux-rasp-pi-g++ -make libs
  -device-option CROSS_COMPILE=<your toolchain path>/bin/arm-none-linux-gnueabi-
  -sysroot <your sysroot path>

The resulting build has full (single process) OpenGL ES 2 support and keyboard support for the Raspberry Pi.

There is no need to patch any files as all the relevant changes have been upstreamed into Qt 5 where they can be adequately reviewed and QAed like any other Qt contribution. Needless to say this drastically increases the quality of the code finding its way on to these devices and should drastically improve the user experience when dealing with this kind of hardware for prototyping/productization/recreation. Sunlight is the best disinfectant, and we delight in consuming this dog food.

We heartily invite any (all!) chipset vendors/chipset customers/BSP vendors or interested parties to upstream relevant mkspecs and the associated code changes to Qt, in order to extend the breadth of Qt 5’s out-of-the-box device support. The move to Open Governance has made extending this support increasingly achievable, feasible and convenient and we are very excited about both Qt 5 as a whole and the current rate of development towards embedded (read constrained) Linux platforms.

The post Cross compiling Qt for the masses appeared first on Qt Blog.

Together with BogDan Vatra, the main author of the Qt for Android port called Necessitas, we have agreed that he will contribute his work into the Qt Project. This is great news and I am truly excited on the things we can do together in the Qt Project. The Qt 5 Android port will be based on the work done in the Necessitas project and BogDan will also continue his work in this area within the Qt Project. This co-operation will enable us to reach Tier 1 status of Qt for Android faster.

Qt for Android is developed actively under the KDE-hosted Necessitas project. There are already many developers who have deployed their apps with it, and an impressive number of users of the Qt-based apps on Android devices – currently over 800.000 active users and 2,7 million downloads. The work done with Qt 4.8 in the Necessitas project provides an excellent baseline to create Qt 5 support together within the Qt Project. Digia is planning to invest into the further development of Qt on Android and aims to introduce Android as fully supported platform of Qt, i.e. as a Tier 1 platform during 2013.

The efforts of getting Qt to run on Android began in late 2010 by BogDan as a hobby project using the newly available QPA of Qt 4.8.  The first Alpha release was made available in February 2011 and the port has been steadily growing with supported features, maturity and amount of users. With Qt 5 Android development moving to the Qt Project, the Necessitas project will still continue the work around Qt 4.8. It is expected that the port on Qt 4.8, currently in beta maturity, will be completed in the coming months with most of the work being able to be leveraged on top of Qt 5 in the Qt Project.

It is truly an impressive achievement to create the Android platform support of Qt as well as the Necessitas SDK extending Qt Creator for Android development, and the Ministro installer that allows applications to fetch the needed Qt libraries.  BogDan has created most of these, but there have been also many others, for example Ray Donnelly, helping him with the port as well as many others providing feedback.

KDE has been a significant help to the work by providing the needed infrastructure to distribute the SDK as well as the Qt libraries for Android devices. We are grateful for this contribution and hope to be able to continue our co-operation with KDE.

BogDan has expressed interest in being the Qt Project maintainer of the Android port, and I think that would be really great! In addition to BogDan, we want to continue the co-operation with the other members of the community, as we do believe that it is the best way to reach excellent results faster. We are also fully committed in keeping the Android port open and available to all Qt licensees, on both commercial and open-source licenses. The Android port is expected to be available as a development project on top of Qt 5 later this year, and reach full maturity with Qt 5.x releases during next year.

At Qt Developer Days next week in Berlin, we will have a couple of demos running Qt applications on the Android Necessitas port. Hope to see you there. Make sure to sign up! www.qtdeveloperdays.com.

The post Necessitas Android Port Contributed to the Qt Project appeared first on Qt Blog.

At the moment most of the buzz is probably around Qt5, but it is good to remember that Qt4 is still alive. While we are working to increase platform coverage on Qt5, there are still some platforms that are officially supported by Digia only with the Qt4 codebase. One of those platforms is Windows Embedded Compact 7. In this blog post I wanted to share with you a small tip that can bring you big performance benefits on Windows Embedded Compact 7.

Windows Embedded Compact 7 is tied to Visual Studio 2008, and if you are targeting an ARM based device you might have realized that the Visual Studio 2008 toolchain only supports ARMV4 and ARVM4i instruction sets for ARM architecture. Due to this limitation, Qt mkspecs for Windows Embedded Compact 7 defaults to ARMV4i instruction set. However, there also exists a version of the Visual Studio 2008 compiler which can generate code for more recent ARM instruction sets and CPU cores. This compiler is included in the Platform Builder (the tool used to generate Windows Embedded Compact 7 OS images and SDKs). If you have Platform Builder installed, you can build Qt for ARMv7 instruction set and also benefit from the more advanced floating point units of the latest CPU cores. To build Qt 4.8.x with ARMV7 instruction set and to use the latest floating point instructions supported by ARM you can do the following:

In the mkspec you are using for WEC7 ARM build, change the value of CE_ARCH variable from armv4i to armv7, and add the following code block there:

QMAKE_CFLAGS    += -QRarch7 -arch:VFPv3-D32 -QRfpe-
QMAKE_CXXFLAGS   = $$QMAKE_CFLAGS

Then make sure that you have the cl.exe from platform builder (c:\WINCE700\SDK\BIN\i386\ARM) in your path before visual studio 2008, and just reconfigure and build Qt and your Qt application. That’s it – now just enjoy the better performance!

For more detailed information about the different Visual Studio 2008 compiler versions, and the options used for QMAKE_CFLAGS, please check the paper written by Adeneo Embedded. With the upcoming Windows Embedded 2013, Microsoft has also updated the Windows Embedded Compact toolchain to Visual Studio 2012.

The post Getting more out of Qt on Windows Embedded Compact 7 & ARM processors appeared first on Qt Blog.

It’s the second day of Embedded World 2013 and as the world of embedded system developers crowd the Nuremberg messe, the Qt team has dry mouth from talking to the hundred of visitors to our booth thus far and showing off the 10+ demos at the Qt stand, #4/520.

It can be said that the embedded industry is still slightly new to the idea of having GUIs on systems like a microcontroller, but this year more and more of the traditional hard-knobs-and-dials sort of developers are coming to Qt because they realize that the world is moving to graphical UIs and especially touch capabilities. They need not only a UI tool, but a full framework that can give them the ability to have a flexible and performing UX on high-end chipset where power and performance are not lost when ported to low-end chipsets and architectures. “I can do that with Qt?” Yes you can.

This year we are showing at our booth Qt running on various embedded operating systems like embedded Linux, QNX, VxWorks, previews of Android and iOS. We also have our “Live Coding Theater” where we are demoing how easy it is to develop with Qt Creator and deploy to an embedded Linux target. This has been very popular being held 3 times a day.

What is really blowing minds is the consistent performance of the same Qt 5.0 application running on QNX, Android and iOS.

What are your thoughts on UI development in the embedded space?

NOTE: Wifi is a bit dodgy at the event – too many people on. Apologies for the pics being slightly heavy and large. We will fix them and update the post throughout the day.

The post Qt Showing off its Portability Power at Embedded World 2013 appeared first on Qt Blog.

Digia has supported Metropolia University of Applied Sciences in their electric car project called Electric Raceabout (E-RA). This cool research project has produced a street legal electric sports car, which not only has the World record on ice, but also runs Qt.

Metropolia University, located in Helsinki, Finland, does extensive research on electric vehicles, one example being E-RA – an electric sports car built primarily by automotive engineering students.

With 4-wheel drive and well designed handling E-RA is a really capable sports car with impressive specs:

• Top speed of over 260 km/h
• Motor power of 282 kW
• Peak torque of 800 Nm – in each wheel

And all this provided by an electric vehicle that is fully street legal (and rest assured, the Finnish road inspection is surely one of the toughest in the world to pass).

E-RA has achieved lap time of 8 minutes 42,72 seconds at Nürburgring Nordschleife, which was electric vehicle track record for quite a while, as well as World record as the fastest electric vehicle on ice with average speed of 252,09 km/h. Nicely driven E-RA has operating range of over 200 kilometers.

The students have built both the IVI system and the instrument cluster with Qt 4.8 running on top of Linux. I think the whole E-RA project is a really great proof of the skills the soon-to-graduate engineers have, and certainly the Qt parts are no less impressive.

Have a look on the enclosed video produced by the students at Metropolia University to hear the full story:

The post Qt in World’s Fastest Electric Car appeared first on Qt Blog.

For a few months now, we have been working on a new project under the codename Boot to Qt, and today we launch it as a technology preview.

Boot to Qt is a commercial offering that provides a fully integrated solution for the creation of slick user interfaces on embedded devices. The offering includes:

• A light-weight UI stack for embedded linux, based on the Qt Framework – Boot to Qt is built on an Android kernel/baselayer and offers an elegant means of developing beautiful and performant embedded devices.
• Ready-made images – We have images for several different devices which include the Boot to Qt software stack, making it possible to get up and running with minimal effort from day one.
• Full Qt Creator Integration – One-click deploy and run on hardware and a fully featured development environment.
• Simulator – A VirtualBox based simulator which allows device development without hardware and opens up for simulating hardware input, such as GPS and  connectivity.

This technology preview focuses on the stack built on an Android baselayer. We also want to provide a similar software stack and the same convenience with ready-made images and IDE integration also for traditional embedded Linux, hopefully with a preview coming some time this summer.

We are expecting to have an official release towards the end of this year.

The following video shows Boot to Qt in action on our reference hardware:

And the following video show the Boot to Qt SDK works:

Scope of Boot to Qt

The software stack includes most of the Qt Framework:

• Qt Core, Qt Gui, Qt Network, Qt Widgets, Qt Xml
• Qt QML and Qt Quick
• Qt Quick Controls
• Qt Graphical Effects
• Boot to Qt specific additions, including virtual keyboard, brightness control and power off/reboot functionality

The hardware devices supported in the Technology Preview are:

• Google Nexus 7 – 1.2 GHz Quad-Core ARM Cortex A9, Tegra 3 GPU, 1GB RAM
• Beagle Board xM – 1GHz ARM Cortex A8, PowerVR SGX530 GPU, 512MB RAM
• Boundary Devices SabreLite (Freescale i.MX 6) – 1 GHz Quad-Core ARM Cortex A9, Vivante GC2000 GPU, 1GB RAM

This is not a fixed set, but a place for us to start. If you have suggestions for other devices, let us know. The stack can also run on x86 hardware.

Performance

Qt 5 introduced a new OpenGL ES 2.0 based scene graph to power Qt Quick 2. This makes Qt Quick very suitable for running on embedded hardware, even those with moderate specs. The demo launcher we ship with the images for instance, runs velvet at 60 FPS on all our hardware devices.

We were looking at CPU usage while playing around in the application launcher on the Nexus 7. When idle, it uses a shader to add a glow on the currently selected item and has a small particle system on the Qt logo in the corner. We found that when the launcher was just animating the glow on the active item and running the small particle system on the Qt logo, the CPU load was running at about 50%. When we flicked it, it dropped to 30% and when the finger was down and we were moving the list via touch, it dropped to below 20%. So it seemed that the more we did, the less the CPU load became. What we were observing was CPU frequency scaling. The CPU is a Quad-core clocked at 1.2GHz (with a special 1.3Ghz single-core operating mode), but when idle, it had disabled 3 cores and had scaled the one remaining core to 102Mhz. So we were able to animate a large part of a 1280×800 screen at 60FPS on a CPU clocked at 102Mhz, and were still only using half of that. 

For reference, the same animation runs at 2% CPU on the i.MX6 and 15% on the Beagle, none of which does do frequency scaling.

We also have pretty decent startup times. Below is a diagram comparing Boot to Qt to native Android. Now of course, full Android brings in a lot of additional stuff, but that is also the point. Most embedded devices do not need that.

Startup times, in seconds, from power-on until device reaches the B2Qt launcher or the Android Homescreen.
Lower is better

This is not too shabby, but we believe we can cut this down a bit more, at least when we start exploring various embedded Linux configurations. As an example,  Qt 5 on Raspberry Pi can start rendering after as little as 3 seconds.

Getting Access

For more information, see the product page.

Boot to Qt is available for evaluation upon request. If you want to try it out or if you are just interested in the software, please use the contact form on the product page and we will be happy to get you started. Of course, feel free to leave comments and questions on this blog too.

Enjoy!

The post Introducing Boot to Qt – A Technology Preview appeared first on Qt Blog.

We are happy to introduce the next iteration of our embedded adventure – Boot to Qt on embedded Linux and some really nice improvements on embedded Android.

As mentioned in Gunnar’s blog post in May, Boot to Qt is the project under which we have been researching and developing an embedded offering for Qt Enterprise edition. The purpose of the project has been to facilitate embedded device creation. This consists of integrated tooling for embedded development and deployment through Qt Creator and a pre-built Boot to Qt software stack for the target hardware. Sincefar, the project has introduced support for the software stack on top of embedded Android.

Introducing Embedded Linux

In Boot to Qt project we have received a lot of requests for adding support also for embedded Linux, so we have put an extra effort into making that happen. The setup on Linux is now here and looking pretty nice, using Yocto and Poky.

We’ve also set up the emulator to support Linux based Boot to Qt as well, so now you can choose to emulate the Boot to Qt software stack behavior on both Android and Linux.

Reference Devices

Here is a list of the current reference devices and which OS we have running on them:

*Due to licensing restrictions on the Yocto recipes for the i.MX 6, this is not bundled into the default installer. If you wish to use the SABRE Lite on Linux, we can help you set it up with minimal effort.

Also, please note that the reference devices above are just examples of Boot to Qt running on different hardware. Setting up Boot to Qt on other devices that run Android or Linux, should not involve much work (including all the tooling and other benefits of Boot to Qt).

1-click Deploy and Run

In this tech preview we have enabled the support for connecting directly to devices using USB. Once your device is set up, you can run your applications on device or emulator with just one click, on both Linux and Android.

This will enable you to regularly check how your changes affect your application on the device, without slowing you down.

Remote Debugging and Profiling

We have put quite some effort into getting remote debugging and profiling working, but it has proven to be a difficult task. Currently we offer debugging of your own code on the following setups:

Currently we support QML-profiling for all the Android and Linux devices.

For Android we have some problems with GDB on the Beagle Board and in the emulator (which keeps us from providing Qt/C++ debugging on these devices). More information can be found on the known issues page.

If you want debugging of the Qt libraries, these need to be built with debug symbols. We have not done this out of the box, as it will increase the size of the libraries, and might end up being to big for some devices.

Supported Modules

To get started with Boot to Qt you can request an evaluation license on the product page. Existing embedded Linux customers will get the upgrade to Boot to Qt for free via the Customer Portal.

One of the big difficulties in embedded projects is setting up the environment and devices for the first time and making applications run on the device. We have made a lot of improvements to the getting started process, and have set up a target that most of you would be able to deploy your first application to an actual embedded device in less than 3 hours (starting with an Ubuntu machine). That’s Boot to Qt.

Looking forward your feedback!

The post Boot to Qt on Embedded Android and Linux – Technology Preview 2 Released appeared first on Qt Blog.

We have spent the past 11 months working on the Boot to Qt project, which started as an internal Digia Qt R&D labs investigation to address some of the challenges with software development for embedded devices.  Since then, the Boot to Qt Project has received a lot of positive feedback from our customers and evaluators, and we are currently at the stage where it’s time to turn it into a real product and integrate it fully into the Qt embedded offering.

We are happy to introduce Qt Enterprise Embedded (Qt EE), consisting of the “Boot to Qt” software stack (v 1.0) and the existing Qt embedded offering from Digia for embedded Linux and embedded Android development.

Embedded Development Made Easy

A key objective of the Boot to Qt project was to enable people to get started with embedded projects quickly by removing the tedious nature of developing for devices and focus on the ease of creating fluid and responsive applications & UIs for embedded systems. This objective lives on in Qt Enterprise Embedded. Here is a video showing how to get started with Qt Enterprise Embedded:

During our usability testing, we found that all our test subjects were able to install Qt Enterprise Embedded and deploy a Hello World application to a device in less than 3 hours.

The following were the types of developers who completed our usability testing:

1. Developers experienced with Qt and embedded
2. Web developers with no Qt or embedded experience
3. Developers experienced with embedded, but no Qt experience

To make sure we were developing a top offering, we experimented a bit ourselves with device creation. (It’s usually healthy to use your own product). Here is a video of how Andy Nichols (Digia, Qt Software Engineer) made a device to aid in learning to play the piano:

Reference Devices

We have set up Qt Enterprise Embedded to run out-of-the-box on a few reference devices (see list below). These are the devices we are using for internal development and testing. However, please note that Qt Enterprise Embedded is not limited to these devices and we can help you get up and running on most hardware targets.

Here is a video showing the different reference devices (and another device we have been playing with) in action.

What’s New in Qt Enterprise Embedded

We have made some significant improvements since the Boot to Qt Technology Preview 2, which have introduced into the final Qt Enterprise Embedded.

Qt Quick and Qt Widgets
With Qt Enterprise Embedded you can develop your applications both using Qt Quick and Qt Widgets.

Qt Multimedia
We have updated the Android version on the i.MX6 and the Nexus 7 to Android 4.2, which was helpful in making Qt Multimedia work on these devices.

Qt Sensors
The sensors API’s on Android seems to be pretty standardized, so we have made Qt Sensors work on Android (can be tested on the Nexus 7). On Linux the sensors API’s seems less standardized, so we don’t have an out of the box solution for sensors on Linux.

Input devices
Touch, mouse and keyboard handling has received fixes to the known issues, so these are fully supported.

New reference devices
In the Boot to Qt Technology Preview 2, some of the feedback was that people wanted the Raspberry Pi as a reference device. This has been done, so now you can use the Raspberry Pi (model B) out of the box with Qt EE. Also, we are now allowed to distribute software from Freescale, which allows us to present the i.MX 6 as a reference device also on Linux.

Supported modules

An overview of the supported modules can be found here.

Supported platforms in Qt

With the launch of Qt Enterprise Embedded Android is introduced as a fully supported embedded platform in Qt.

Documentation

The documentation for Qt Enterprise Embedded can be found here.

Versions

The “Boot to Qt” software stack (v 1.0) is based on Qt 5.1 and Qt Creator 2.8.

Qt Enterprise Embedded in Action

We are really happy to announce that one of the early adapters of the Boot to Qt Project is already in production. You can read more about their experiences on the product page

Getting Started

To get started with Qt Embedded Enterprise, you can request a free 30-day trial via the try now page.

Existing Qt Enterprise customers with an embedded Linux license can access the Qt Enterprise Embedded installer in Customer Portal download area.

We are looking forward to your feedback!

The post Introducing Qt Enterprise Embedded (aka Boot to Qt) appeared first on Qt Blog.

We’re proud to announce that Qt 5.2 is now available. With the release of Qt 5.1 in July, we showcased the Qt for Android and iOS ports and laid down the beginning of some heavy improvements we have now done on Qt’s graphics capabilities. In the last 6 months, we’ve worked very hard to finalize this release and especially these ports.

Qt on Mobile Is Here with Great Opportunities

I am proud to say that Qt 5.2 fully brings Qt into the mobile space as a true player in the app development market supporting Android, iOS, BlackBerry, Sailfish/Jolla and Ubuntu Mobile. With this, Qt is the native cross-platform development framework with the broadest support of operating systems in the mobile space, complementing our even wider support of operating systems for desktop and embedded development. Qt 5.2 makes it very easy to take your existing desktop or embedded applications and bring it to mobile phones or tablets.

To show our commitment to being fully cross-platform also on mobile, we have an additional small christmas present for you. I am excited to announce that we now also have a Technology Preview of Qt for WinRT available. The preview is based on our development branch, and thus contains already a few of the new features to be found in Qt 5.3.

Qt on Android and iOS

Most of the Qt APIs are supported with Qt 5.2 both on Android and iOS. Since these are new platforms there are, however, some exceptions. Qt WebKit is not yet supported on Android, and can’t be brought to iOS due to App Store policies. But we are working on bringing an easy way to embed web content via Qt APIs to these mobile platforms in the future. In the meantime, we recommend the use of native web elements. Qt Bluetooth and Qt NFC are also not yet supported and will get implemented in a subsequent release.

All of our other APIs (including Qt Quick, Qt Sensors and Qt Multimedia) are fully supported on these platforms, allowing the development of a very wide class of applications with Qt APIs only. If something is not yet supported with the Qt APIs you can also always fall back to using some of the platform’s native APIs, where needed. For Android, we provide a convenience API for using the Java Native Interface (JNI) through the new Android Extras module. For more details, you can read the blog post about Implementing In-app purchasing on Android.

Developing Qt applications on mobile can be done fully within the Qt Creator IDE for Android, BlackBerry and Sailfish. On iOS, the Qt Creator support is still experimental.

With Qt 5.2, we are also introducing our Qt Mobile edition , which we announced in October at Qt Developer Days Berlin. Qt Mobile edition is a specially tailored package for mobile app developers that will help you target the fragmented mobile markets with one technology.

Besides new mobile platforms we’ve also continued working hard on the existing platforms. More than 1500 bugs have been fixed since the release of Qt 5.1.1. The desktop platforms have received a lot of focus with multiple improvements all around the libraries and by bringing in platform-specific support through new modules.

Great Improvements for the Desktop

Qt on desktop operating systems is the heart of Qt and has served as a stepping stone for the immense breadth of our operating system support throughout the years. That said a lot of improvements have happened with Qt 5.2 that are mainly targeting the desktop operating systems.

• We’ve further improved the Qt Quick Controls for the desktop and made it easier to integrate Qt Quick into traditional QWidget-based applications
• A lot of enhancements and bug fixes went into the Qt Widgets module
• We added a new QKeySequenceEdit QWidget class making it easier to deal with user configurable key bindings
• Accessibility is now fully supported on all desktop platforms (and Android)
• Qt Windows Extras module: Integrate with native code on Windows
• Qt Mac Extras module: Integrate with native code on Mac OS X
• Improved time zone and locale support with QTimeZone and QCollator
• Bluetooth is supported for Linux with Qt Bluetooth module
• Many fixes to improve support for OS X Mavericks

All of these changes together make Qt 5.2 an excellent basis for your desktop application.

Revamped Qt QML and Qt Quick

A huge amount of things have also changed under the hood. The Qt QML module has gotten a brand new engine, removing our dependency on the V8 JavaScript engine. The new engine is built from the ground up for Qt and with QML as the main use case in mind. It supports an interpreted mode, and can thus run on CPU architectures where JIT would not be available or platforms such as iOS where JIT’ing is not allowed by App Store policies. In earlier Qt versions, the integration with the V8 JavaScript engine was difficult and led to performance issues when crossing the boundary between the Qt and JS code bases. This problem has now been resolved by the new engine, which directly uses Qt data types and can quickly interact with all Qt code.

As a net result of these changes, you should see some performance improvements for most QML use cases. However, as Qt 5.2 is only laying down the foundation, performance when executing lots of program logic in JavaScript will be slower than with Qt 5.1. Qt 5.2.1 will bring quite some additional speed improvements and we have great plans for the engine in Qt 5.3.

A lot has also happened on the Qt Quick side of things. The renderer for the Scene Graph has been completely rewritten delivering much improved rendering performance for applications and freeing up more CPU time for the application itself. In addition, every QQuickView now renders in a thread of its own, ensuring that multiple scenes don’t block each other.

Qt Quick has also gotten support for a new animation type called Animator, which allows you to run many animations fully on the rendering thread. These animations cannot be blocked even if the main thread would be heavily loaded doing some extensive calculations.

Qt Creator 3.0 and Other Goodies

Qt 5.2 ships together with the new Qt Creator 3.0. The new Qt Creator improves support on mobile platforms and improved stability of it’s plugin APIs. This will create a foundation for 3rd party plugin extensions for Qt Creator, something we’re looking forward to expanding more in the future.

A couple of new modules and APIs also made it into Qt 5.2. Most notable are probably the support for positioning with the Qt Positioning module, Bluetooth support for Linux and BlackBerry with the Qt Bluetooth module, NFC support on BlackBerry, support for time zones and Unicode collation and the new Windows, Mac and Android Extras modules.

Qt WebKit has also received a major update now being based on a WebKit version from this summer. This includes many new features such CSS Blending, Geolocation, Web Notifications and a threaded garbage collector.

Qt in Action

We’ve deployed a couple of Qt Quick applications to the mobile marketplaces for you to try out. The “Quick Forecast” is a weather application using a web API and implemented completely with Qt Quick Controls. You can get it for Android from Google Play and for iOS from the App Store.

Learn More about Getting Started with the New Platforms

In the beginning of 2014, we are coming to meet you in person at a few locations around the world with our Qt Mobile Roadshow. The event is a full-day free developer event on how to get started developing cross-platform mobile applications with Qt. The locations and dates can be found here.

We are also organizing a couple of specific webinars around Qt for Android and iOS where you will get hands-on information on how to get started developing:

• Qt on iOS, Hands-On – Dec 17th 2013
• Multiscreen Development with Qt | Business Overview – Jan 9th 2014
• Qt on Android, Hands-On – Jan 16th 2014

Please find the detailed webinar information registration from http://qt.digia.com/webinars.

Download & Try

You can download Qt 5.2 from our download page on http://qt-project.org or try the Qt Enterprise 30-day free trial from http://qt.digia.com. Qt Enterprise customers can access the Qt 5.2 release directly from their customer portal. If you are only targeting mobile, you can also download a 30-day free trial of Qt Mobile from http://qt.digia.com/Try-Buy/Choose-Plan/.

Thanks!

Last but not least, I’d like to thank everybody that has contributed to making Qt 5.2 the best Qt release yet. Many people from the community have worked very hard to make this release happen. I’d especially like to thank KDAB, Bogdan Vatra and the Necessitas project for their significant efforts and contribution to Qt 5.2. Also, I would like to extend a warm thank you to the KDE community that has contributed many interesting and valuable features, and our release team that did a lot of hard work behind the scenes pulling everything together into a releasable package.

We hope you enjoy Qt 5.2 as much as we enjoyed making it. Happy holidays!

The post Qt 5.2 Released | The Best Qt Yet appeared first on Qt Blog.

One of the items those who create embedded touchscreen devices with Qt often request is a good, extensible virtual keyboard. We have listened, and I am extremely happy to announce that a Technology Preview of the new Qt Virtual Keyboard is available as a value-add component for Qt Enterprise customers.

There is already a simple virtual keyboard available for Qt Enterprise Embedded, but now we are releasing a Technology Preview of a new and completely re-implemented virtual keyboard. It provides a solid base to be used in various different embedded devices, especially ones with a touchscreen user interface. Because the virtual keyboard is fully licensed under Qt Enterprise, it can easily be included into all kinds of embedded devices without concerns for 3rd party license compatibility, as well as extended with both commercial and open-source spell checkers and word prediction engines. The new virtual keyboard allows for a fully custom visual appearance. We provide two example styles with the Technology  Preview: one modern and one retro style.

English keyboard layout:

The following video contains a short overview of the key functionality of the new virtual keyboard as well as a demonstration of how nicely it integrates with Qt Enterprise Embedded:

The virtual keyboard technology preview is available for download from the Qt Enterprise Customer Portal, or via the Qt Enterprise online installer. The technology preview is intended for Linux, embedded Linux and embedded Android on top of Qt 5. The virtual keyboard will also be a pre-integrated component in the upcoming major update of Qt Enterprise Embedded. For more information, please check out the virtual keyboard product page.

The post New Virtual Keyboard for Qt Enterprise appeared first on Qt Blog.

I am really excited to announce a major update to our embedded offering. The new version of Qt Enterprise Embedded brings many valuable and highly requested features available to all our embedded customers. Combined with the features of the first version, the new release sets ease and productivity of Qt development for embedded targets to a level it has never been before.

Qt Enterprise Embedded brings flexibility to embedded development for creation of beautiful, high-performing and modern UIs. With built-in, fully integrated, productivity-enhancing tools, embedded software development becomes a breeze. The pre-configured embedded development environment, pre-built Qt optimized software stack for immediate deployment to reference boards and a large set of value-add components and tools allows developers to get up and running immediately. With Qt Enterprise Embedded it is possible to have a working embedded project prototype from day one – and continue with unparalleled productivity and time-to-market throughout the project.

Highlights of the new features of today’s release include:

• Qt-optimized Yocto recipes for building your own embedded Linux stack
• Boot to Qt stack updated to use Qt 5.2.1
• Emulator graphics performance and quality improved with GL-streaming
• Qt Virtual Keyboard integrated
• Qt Quick Enterprise Controls integrated
• Qt Charts integrated
• BeagleBone Black added as a reference device for both embedded Linux and embedded Android
• WiFi networking and Ethernet connectivity support implemented for embedded Android
• Updated GDB for embedded Android toolchain

 

In addition to these, we have improved the documentation, polished the first time user experience, optimized the most common use cases and improved the items reported by customers and evaluators of the earlier releases. One of the biggest new features is the availability of the Yocto tooling and recipes, as well as Android build scripts for all customers to be able to re-bake the operating system stack. We have used Yocto recipes internally for long time to build the reference images for embedded Qt as well as in conjunction with services. Now, we are providing these also for the customers to use as a Qt-optimized baseline for their devices.

We have also integrated our latest commercial value-add items: Qt Quick Enterprise Controls and the new Qt Virtual Keyboard into the Qt Enterprise Embedded product. These items, as well as all other features of Qt are available under a commercial license well suited for the creation of embedded devices. Qt Enterprise Embedded also comes with our renowned technical support with tight connection to the core of Qt R&D to ensure customer success even in the most demanding embedded projects.

For more details check out Qt Enterprise Embedded product page, the press release we issued today about the new release, the full changelog for the release , and online documentation for Qt Enterprise Embedded. If you happen to be around Nuremberg, come and visit us in the Embedded World 2014, Hall 4, stand 4-408. We have a lot of great demos running Qt Enterprise Embedded as well as many experts available to talk with.

Existing Qt Enterprise customers with an embedded Linux or embedded Android license can access the Qt Enterprise Embedded installer in the Qt Enterprise Customer Portal download area, or use the online installer they already have to get all the new goodies.

To get started with Qt Enterprise Embedded, download the Free 30-day trial of Qt Enterprise Embedded, or contact us using the online form.

The post Major Update to Qt Enterprise Embedded Released appeared first on Qt Blog.

We are in our second day at Embedded World 2014 (Nuremberg, Germany), the largest embedded systems show in Europe.

Together with some of our partners, KDAB, ICS, e-GITS and Adeneo Embedded, we are showcasing over 15 demos showing the power of Qt on various embedded platforms.

In the past couple of days, visitors to our booth have been looking for a quick and efficient way to develop application or devices in various embedded industries like automotive, medical, industrial automation and household appliances. Touch user interfaces are now the norm in industries where just a couple of years, fluid or graphics-intensified UIs were not hard requirements. Embedded-focused companies are looking to provide their end users with an easy-to-use, i-Phone-like and consistent user experience that also spans various form factors and operating systems. Judging the crazy traffic to our booth, Qt and the Qt Enterprise Embedded offering seems to be the hallelujah answer to the trials and tribulations many face in software development for embedded systems.

Qt is not a new kid on the block  in the embedded development world and we noticed while perusing the trade show halls that it is truly everywhere with several companies in all five exhibition halls showing their own embedded capabilities demoing Qt-powered demos. We like!

Below are a few snap shots of the activity, demos and customer projects we are showcasing at Embedded World 2014. If you are at Embedded World 2014, come by our booth and say hello. We’ll give you a t-shirt and some Qt goodies. If you are exhibiting at the show and are showing a Qt-powered demo, give us a shout out. We would like to see it in action.

Until next time!

Qt at Embedded World 2014

Qt Enterprise Embedded Live Coding

Qt Enterprise Charts & Data Visualization

Digia Qt Partners (ICS, KDAB, e-GITS, Adenneo Embedded)

IPO.Log customer project. Qt in Industrial Automation

Qt in Automotive

The post Embedded World 2014 | Qt on Embedded Buzzing appeared first on Qt Blog.

Embedded World 2014 was a great event and we had busy 3 days showing over 15 great Qt demos shown together with our customers and partners. So, a big thank you to everyone who joined us at Embedded World 2014! Below is just a small snippet from the three days packed full of demos, discussions, “LIVE Qt Coding” theatre sessions and a lot of networking!

If you want to check details of the demos we showed together with our customers and partners, please visit our Embedded World 2014 event page.

To get started with Qt Enterprise Embedded, check out our Free 30-day Trial, or contact us to learn more.

The post Embedded World Revisited appeared first on Qt Blog.

It’s time for an update on Qt Enterprise Embedded – featuring Qt Creator 3.1.0, integrating new Qt Enterprise modules, connectivity improvements and a few other items we hope you will like. For Qt Enterprise Embedded, we are providing regular patch updates with bug fixes, enhancements and pre-built versions of our latest Qt Enterprise components.

Here is an overview of what we have done since last time:

Cloud-Connect Your Device

As cloud-connectivity is part of modern embedded device creation, we’ve made it even easier to integrate into Qt Cloud Services. Access to Enginio Data Storage is now provided built-in with the Qt Enterprise Embedded. Through Qt Cloud Services, you can immediately instantiate a whole cloud backend for you embedded, mobile and desktop Qt clients–all through a convenient Qt API. Together with the newly added Bluetooth support (using BlueZ) and the existing Wi-Fi and wired network support, you have everything you need for implementing Internet-of-Things, all within the reach of single technology.

Qt Data Visualization library

For 3D visualization of data we’ve integrated the Qt Data Visualization library to the built-in offering. With the library you can create amazing and well-performing 3D visualizations using 3D bars, 3D scatters and 3D surfaces.

Qt Quick Enterprise Controls (version 1.1)

With Qt Enterprise Embedded we provide a complete set of Qt Quick UI controls to give you a head-start in modern UI development. Both basic Qt Quick Controls as well as the industry-specific Qt Quick Enterprise Controls are built-in to the software stack as well as the UI designer in the development environment. Qt Quick Enterprise Controls is a continuous project where we’ve implemented and provide support for more complex, industrial UI components that are requested by our customers. This release adds a couple of more controls in addition to previous ones and should you have ideas for new ones, let us know!

QSerialPort

We are fortunate to live in a world with USB, Wi-Fi, Bluetooth etc, but sometimes it’s useful to be able to connect some copper wires to the serial port. The QSerialPort API allows you to access both physical and virtual serial ports using a convenient cross-platform API as well as use the Qt streaming classes to read/write data to the port.

Other improvements:

In this release we introduce the possibility for incremental deployment to devices. This reduces the time it takes to deploy your software to your device.

Previous versions of Qt Enterprise Embedded offered USB-connection to the device as the primary way to deploy, run and debug on devices. In addition to USB we are now supporting also connecting to devices in your local network using IP. This should ease sharing of devices among team members, setting up devices for automated testing etc.

We have also updated the OpenSSL library with a fix for the Heartbleed Bug vulnerability.

In addition we have made quite a few updates to our documentation.

We have also put a lot of effort into fixing issues that our users have encountered so far. Further information can be found on the change log.

Reference Devices:

Our reference devices are ones we have set up to run out-of-the-box with Qt Enterprise Embedded, great for evaluating and prototypic. Qt Enterprise Embedded is not limited to these devices, and we are happy to help you up and running on other devices. In fact, for the Embedded Linux based software stack, we provide many more recipes directly for the Yocto Project’s tooling for you to customize your own stack for production.

Getting Started

Request a Free 30-day trial via the Try Now page to get started with Qt Enterprise Embedded.

We are looking forward to your feedback!

The post Update for Qt Enterprise Embedded appeared first on Qt Blog.

It has been a while since our last blog post and we would like to provide a short summary of our work and our future plans.

In the meantime, we have added several interesting features such as support for WebRTC or the system clipboard. We added support for Tooltips and Find Text to the Widgets API. Also, we spent a significant amount of time expanding our APIs and verifying these by porting example applications from Qt WebKit to Qt WebEngine.

Qt WebEngine in Action

The following video shows Qt WebEngine in action on multiple platforms. Some very exciting features shown in the video include WebRTC being used for video conferencing and WebGL and CSS animations running on embedded linux. Further it also shows HTML5 Video running on an off-the-shelf embedded device.

Focusing on Embedded

Since last year, we have been working on getting Qt WebEngine running on Linux and Mac OS X. These are already running pretty well as shown in the video above. However, given the market requirements and the high number of requests received for web content on embedded platforms, we have had to slightly shift the team’s focus. Having a well performing, high-quality web engine is a key requirement for many embedded devices, and we want to cater to these with the upcoming release of Qt WebEngine. Therefore, in the past few months we have placed more emphasis on the embedded Android and embedded Linux operating systems that form part of Qt Enterprise Embedded.

Although, the team’s focus has moved to embedded on the short term, there is ongoing work happening to fully support Windows.

So far we have Qt WebEngine running on the following reference devices which are supported through Qt Enterprise Embedded:

embedded Linux:

• Raspberry Pi model B (Broadcom BCM2835)
• Boundary Devices SABRE Lite (Freescale i.MX 6)
• BeagleBone Black (Texas Instruments AM335x)

embedded Android:

•  BeagleBone Black (Texas Instruments AM335x)
•  Google Nexus 7 (Nvidia Tegra 3)

Furthermore, Qt WebEngine is also running on desktop Linux and on Mac OS X.
The work to add support for Windows is on-going.

Upcoming Releases

We will first ship Qt WebEngine with the Qt 5.3 version of Qt Enterprise Embedded coming soon. At this point, Qt WebEngine will be a Qt Enterprise Embedded only release and will include support for the embedded platforms mentioned above. We are expecting to receive a lot of feedback from our embedded users and this will help us to release an even more improved version also for desktop with Qt 5.4.
Qt WebEngine is a solid and future proof solution for Qt-based embedded devices requiring a web engine.

Support for further platforms

Support for further platforms, in particular the desktop platforms will then be added with our 1.0 release which we are currently planning to have with Qt 5.4. We are putting significant effort into easing the porting from Qt WebKit to Qt WebEngine. Qt WebKit remains supported for all desktop platforms with both Qt 5.3 and 5.4, so each application can migrate to Qt WebEngine when desired.

The post News from the Qt WebEngine Team appeared first on Qt Blog.

We are happy to release an update to Qt Enterprise Embedded with lots of new features based on the recently released Qt 5.3

What is Qt Enterprise Embedded?

Qt Enterprise Embedded is a full solution for creating embedded devices, with Qt Enterprise libraries, using a fully integrated development environment, along with a pre-built Qt-based software stack – called Boot to Qt.

What is new in this release?

Qt Enterprise Embedded is taking a giant leap forward with the following new highlights:

• Improved performance, protection and device boot-up-time through compiled Qt Quick. Now you can compile your dynamic QML files into C++ code using the Qt Quick Compiler, securing the contents as well as reducing the device boot-up-time by having the UI files pre-compiled. It also increases the run-time performance for every loadable QML file.
• Unbeatable Web / Hybrid Offering through Qt WebEngine.  As powerful as native UIs with Qt Quick are, we also want to welcome HTML5 as a first-class citizen of Qt-powered devices. The new, Chromium-based Qt web offering is available with Qt Enterprise Embedded. Choose the best of all worlds: make native applications with Qt Quick, re-use dynamic web content with Qt WebEngine and flair it up with OpenGL shaders. This version of Qt WebEngine supports several features like HTML5 Video, WebGL and WebRTC (The exact set of features depends on hardware and configuration.). Read more about Qt WebEngine from this blog post.
• Shorter Time-to-Market with the pre-built software stack and tooling. You need to experience it yourself. Using the pre-built “Boot to Qt” software stack, and integrated tooling, makes embedded development significantly easier. We have updated and enhanced the stack into version 3.0, both on embedded Android and Linux. This enhances the out-of-the-box evaluation experience, and provides you with the tools you need to customize the software stack to fit your product and hardware needs. Besides just creating immediate device prototypes, you can take it up to production to match your final hardware and middleware requirements.
• Comprehensive collection of value-added solutions. Why spend time re-inventing the wheel? We have implemented a collection of complex solutions to speed-up your time-to-market. The Qt Virtual Keyboard is now fully supported with version 1.0 that introduces new language layouts, fixes bugs and stabilizes the APIs. Besides the keyboard you get full access to Qt Enterprise Charts, Qt  Enterprise Data Visualization and the Qt Quick Enterprise Controls.
• Create connected devices – explore our Qt Cloud Services portfolio. With the new Qt WebSockets API you can create real-time bi-directional connections between two clients. The integrated Qt Cloud Services extend this with a new Managed WebSockets service that allows you to add a ready-made server implementation. Along with Enginio Data Storage and Managed Runtimes (let you put your implementations on the server-side – available for early-access on request), the Qt Cloud Services gives you a complete portfolio of backend solutions—all bundled into Qt Enterprise Embedded.

With the cross-platform (embedded, desktop and mobile) libraries and integrated cloud solutions, we believe you have the tools needed to implement your visions for the Internet of Things today.

See how Qt Enterprise Embedded provides you with the technical enablers for your connected devices:

Reference devices

In this release we have added new reference hardware: the Nexus 7 (2013) and the SABRE Board/Platform for smart devices. The reference devices are provided with a pre-built Boot to Qt software stack and can be used easily for prototyping and evaluation. For other production hardware, you can customize the stack with provided tooling.

Here is the complete list of current reference devices:

Further information

Further information can be found in the product page, from the change log  and in the Qt Enterprise Embedded documentation.

Getting started

To help you get started we are hosting two webinars shortly. Title: “Speeding Up Embedded Development”:

• Europe: June 3rd, 10am CET: Sign up! https://qt-digia.webex.com/qt-digia/onstage/g.php?t=a&d=959191785
• Americas: June 3rd, 8am PST / 11am EST: Sign up! https://qt-digia.webex.com/qt-digia/onstage/g.php?t=a&d=956087374

Request a Free 30-day trial via the Try Now page to get started with Qt Enterprise Embedded.

We are looking forward to hearing from you!

The post Qt Enterprise Embedded Updated to Qt 5.3 appeared first on Qt Blog.

We released Qt 5.3.1 a week ago and now we’ve updated the Qt Enterprise Embedded offering as well. In addition to the Qt framework upgrade, we have developed a few new interesting features and also updated the tooling and some of the enterprise add-on features. We are especially proud about our new Android injection solution that lets you take the Boot to Qt software stack into a large variety of Android devices with little effort.

With this update we are also introducing the first Qt supported CoM, Computer-on-Module, for embedded Linux as we announce official support and pre-built binaries for Apalis i.MX6 CoM module from our Qt Technology Partner Toradex. Using the Apalis i.MX6 module from Toradex with our pre-built Qt stack, you can reduce the needed HW and SW effort enabling fast and cost-efficient creation of various embedded systems directly leveraging the state-of-the-art features of this powerful combination.

Qt 5.3.1, Qt Creator 3.1.2, Qt Quick Compiler 1.0 and an updated Qt WebEngine

Qt Enterprise Embedded comes with the pre-built Boot to Qt software stack, now built using Qt 5.3.1, which allows you to immediately start prototyping and developing your product. And if you happen to need some changes to the stack as well, don’t worry; you can easily modify the stack with the provided tooling.

Today’s update includes a fully supported Qt Quick Compiler 1.0. The Qt Quick Compiler takes the declarative QML files and compiles them into native code, thus improving application load times significantly. With Qt Quick Compiler the typical Qt Quick application load times are reduced by 30%-40%, with maximum gain being up to 90% with highly JavaScript intense applications.

The Qt Creator IDE has also received bunch of enhancements through an update to Qt Creator 3.1.2.

Qt’s all-new Chromium-based web engine was first introduced as part of Qt Enterprise Embedded in the previous release. With the received feedback, we are bringing in some enhancements and bug fixes to Qt WebEngine as well. With this release we enabled multi-process support for eAndroid as well, and added support for the new generation Nexus 7 (2013) as a new device. Besides that QtWebEngine received a lot of stability and other bug fixes having an effect on both the eAndroid and eLinux configurations.

Take “Boot to Qt” Anywhere with New Android Injection

So far we’ve distributed pre-built images of the Boot to Qt software stack for a set of reference boards and separate tooling to customize the contents and target hardware. For embedded Linux, we’re providing the recipes for Yocto project tooling to do the customization.

Now, we are introducing a whole new Build-Your-Own-Device tooling for embedded Android that works through an injection model. This means that instead of flashing a device with a complete stack, the Boot to Qt contents are injected into an existing Android image on a device.

The effect is that almost any recent, programmable Android device can be turned into an embedded Qt-powered device with little effort. This makes your set of potential prototyping devices huge and lets you conveniently do small batch production devices with low-cost bulk Android hardware.

To read more about how this works in practice, check the separate blog post.

First Qt Reference CoM with Toradex Apalis i.MX6

We are proud to introduce our first CoM, Computer-on-Module, reference platform for embedded Linux. CoM is a complete embedded computer on a single circuit board, which can easily be integrated into a custom embedded hardware design.

Usage of CoM in your embedded hardware makes maintainability and upgradability a lot easier when compared to more traditional fully-integrated embedded hardware solutions.  It also reduces hardware development time significantly, allowing you to focus on things that really matter to you on hardware design, leaving the processing unit design complexities out of the picture. When combining this with the Qt Enterprise Embedded offering, you will have your devices ready for market in no time.

Toradex Apalis i.MX6 is a leading-edge embedded CoM, based on quad core Freescale i.MX6 SoC, System-on-Chip. Apalis i.MX6 supports a wide variety of industry standard interfaces, high speed connectivity and advanced multimedia features making it an ideal choice for even most demanding embedded system designs.

Updated Value-Add Components

Virtual Keyboard 1.1

The Qt Virtual Keyboard has received a minor update that brings in more keyboard layouts, Chinese input, sound feedback and 5-way navigation that allows you to use the virtual keyboard with a hardware input device (such as a joystick/scroll-wheel). Read more about the 1.1 version in the separate blog post.

Data Visualization 1.1 and Charts 1.4

Both Data Visualization 1.1 and Charts 1.4 contain a lot of improvements and new features requested by our customers.

The most important improvements in Data Visualization for embedded customers are the performance optimizations. Data caching is now optimized when only a part of the data changes. In addition there are also some experimental optimizations. Also Charts 1.4 includes a bunch of improvements and new features. For example, QML API has been improved to make it easier to use Charts in Qt Quick applications.

More details about these releases is available in blog post.

Further information

Further information can be found in the product page, from the change log and in the Qt Enterprise Embedded documentation.

Getting Started

You can update your product using the package maintainer, download a new version from Qt Account or request a Free 30-day trial via the Try Now page to get started with Qt Enterprise Embedded.

To help you get started you can take a look at our recent webinar recording that introduces Qt Enterprise Embedded in action:

The post Introducing Android Injection with Qt Enterprise Embedded 5.3.1 appeared first on Qt Blog.

Android Injection

Qt Enterprise Embedded provides pre-built system images for a range of popular devices, like the Nexus 7 tablets and the BeagleBone Black. With these, you can make your device “boot to Qt” and be up and running with embedded development literally within minutes. But what if you want to try a device that is not among these reference devices of Qt Enterprise Embedded? Until recently, as an evaluator, you were basically out of luck. And even with an Enterprise license, you would have to rebuild the image from scratch for your device, a process that can take some time. Now, with the recent update of Qt Enterprise Embedded, there is another option available. If your device runs a recent version of Android, it is now possible to install the Boot to Qt stack directly into the existing Android system image; in effect taking it over. We call this method Android injection. In this blog post we will show how this process works in practice. We will use a device called the ODROID-U3 as our example.

The Injection Steps

The installation process consists of the following:

1. Unpacking the Boot to Qt system and data archives into the /system and /data folders of the Android system
2. Creating a device configuration file, appcontroller.conf
3. Changing the Android boot script (init.rc) to make the device boot to Qt instead. We provide a script to perform the necessary changes.

As you can see, this is not very complicated. However, it cannot easily be automated, since  every device has different ways of packing the file systems and boot files. So a little manual effort is required.

The ODROID-U3 Device

This device is created by Hardkernel and has a quad-core Cortex-A9 processor, Mali-400 graphics processor and HDMI display output, and Android builds are available. For the injection process, any Android 4.2 or 4.4 image should do. For this blog post, I downloaded the Android 4.4 SD card image from here, and installed is as explained here. After booting twice, the device runs Android fine:

1. Unpacking the Boot to Qt system and data archives

The bulk of the Boot to Qt injection stack comes in the form of two tarballs, intended to be unpacked into Androids /system and /data folders respectively. On most Android distributions, those folders have separate partitions on the storage device. We need to determine which partitions that is. One way is to log in to the device and study the /fstab file, which will show where the partitions will be mounted. Like this:

~/odroid$ adb shell cat /fstab.odroidu.sdboot
# Android fstab file.
#                                                              
# The filesystem that contains the filesystem checker binary (typically /system) cannot
# specify MF_CHECK, and must come before any filesystems that do specify MF_CHECK

/dev/block/mmcblk0p2    /system             ext4      rw                                                    wait
/dev/block/mmcblk0p3    /data               ext4      noatime,nosuid,nodev,nomblk_io_submit,noauto_da_alloc,errors=panic    wait
/dev/block/mmcblk0p4    /cache              ext4      noatime,nosuid,nodev,nomblk_io_submit    wait
/devices/platform/s3c-sdhci.2/mmc_host/mmc0 auto    auto    defaults voldmanaged=sdcard0:1,noemulatedsd
/devices/platform/dw_mmc/mmc_host/mmc0      auto    auto    defaults voldmanaged=sdcard1:auto
/devices/platform/s5p-ehci                  auto    auto    defaults voldmanaged=usbdisk:auto

As we see, in this case /system and /data are on partitions 2 and 3 respectively. After powering down the device, and plugging the SD card into the host PC where the Qt Enterprise Embedded SDK is installed, we are ready to do the unpacking. Here, the SD card appears as /dev/sdb, and the SDK is installed in ~/QtEE31:

~/odroid$ mkdir p2
~/odroid$ sudo mount /dev/sdb2 p2
~/odroid$ sudo tar x -C p2 -f ~/QtEE31/Boot2Qt-3.x/generic-4.4-eAndroid/images/system.tar.xz 
~/odroid$ mkdir p3
~/odroid$ sudo mount /dev/sdb3 p3
~/odroid$ sudo tar x -C p3 -f ~/QtEE31/Boot2Qt-3.x/generic-4.4-eAndroid/images/data.tar.xz

# Checking that things look good so far:

~/odroid$ ls -l p2/bin/qtlauncher
-rwxr-xr-x 1 root root 173420 Jul  1 21:41 p2/bin/qtlauncher
~/odroid$ ls -ld p3/user/qt
drwxr-xr-x 21 root root 4096 Jul  1 21:41 p3/user/qt/

2. Creating a device configuration file

The Boot to Qt stack needs a few environment variables and other device-specific settings. These are stored in plaintext format in the file /system/bin/appcontroller.conf. (Granted, that is not the most natural place for a settings file, but for now, that is where it is). One can see examples for different reference devices in the directories in Boot2Qt-3.x/generic-4.2-eAndroid/images. For the ODROID-U3, we store the following in p2/bin/appcontroller.conf:

#env=QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS=/dev/input/event0
env=QT_QPA_EGLFS_NO_SURFACEFLINGER=0
env=QT_LOGGING_TO_CONSOLE=1
env=QML2_IMPORT_PATH=/data/user/qt/qmlplugins
env=QT_IM_MODULE=qtvirtualkeyboard
base=android
platform=odroidu

Since we do not have a touch screen connected, the line setting the touch screen device has been commented out.

3. Changing the Android boot script

This step can sometimes be a little tricky. The boot script (init.rc) is always in Android’s root file system. But many Android distributions package the kernel and the root file system into a special binary boot image format, and place that in a separate partition. That partition is then not mountable and modifiable like a normal file system. Instead, special scripts must be used to unpack it and repack it after modification. One can easily search up information about the process on the net.

In other cases, the boot script is available as a plain file. That is the case for our sample device, we find the ODROID’s init.rc
file in the root directory of partition 2. The modification process itself is made very simple by a script provided in the Qt Enterprise Embedded SDK:

~/odroid$ sudo cp p2/init.rc p2/init.rc.orig
~/odroid$ sudo sed -f ~/QtEE31/Boot2Qt-3.x/generic-4.4-eAndroid/images/generic/modify_init_rc.sed -i p2/init.rc

# Checking that the modification succeeded:

~/odroid$ tail -1 p2/init.rc
    start boot2qt

Ready to rock!

All that remains is to unmount the SD card:

~/odroid$ sudo umount p2
~/odroid$ sudo umount p3

Now, with trembling fingers take the SD card with your brand new Boot to Qt image and plug it into the device. Then apply the power supply and wait for the screen of success:

(If your device should not start up like this, try to look for error messages in the output from adb logcat and adb shell appcontroller qtlauncher.)

At this point, it is easy to set up your linux host and Qt Creator for one-click deployment of your apps to your device. Just follow the simple instructions for “Setting up USB Access” and “Configuring a Device Kit in Qt Creator” in one of the Android device preparation pages. Then, you are all set to start Building and Running Embedded Applications!

The post Making an Android device boot to Qt appeared first on Qt Blog.

For creating devices with Qt, we offer a whole toolkit consisting of Qt libraries, pre-built but customizable software stack (Boot to Qt), value-add components and full embedded tooling around the Qt Creator IDE.

Now, It’s time to update our offering by updating the pre-built Boot to Qt software stack with the latest Qt 5.3.2 and upgrade some of the provided value-add components. Also Qt Creator IDE has been updated since our last update. To read more about the whole toolkit for creating devices with Qt see the documentation overview.

Qt 5.3.2 packs a bunch of bug fixes and improvements to functionality based on feedback and reports we have received. Qt 5.3.2 maintains backward and forward compatibility, both source and binary, with Qt 5.3.0 and the latest, 5.3.1, which was released this June. See more from the Qt 5.3.2 release blog post.

Many of our value-add components have been updated as well. The Qt Quick Compiler has gotten it’s first update, Qt Quick Enterprise Controls have been improved by adding the frequently requested Tumbler control and the Qt Virtual Keyboard is now updated to version 1.2 that provides new layouts and features.

Qt Creator IDE has also been updated with a patch release to version 3.2.2. The Qt Creator 3.2.2 patch release contains a few essential fixes for the embedded functionality on top of fixes provided by the Qt Creator 3.2.1 update from about a month ago.

Qt Virtual Keyboard 1.2

The initial version of the Qt Virtual Keyboard was introduced early this year, and version 1.1 before summer. It is a great choice if you are in need of an extendable virtual keyboard on your embedded device, or as part of your embedded application.

It now has no less than 16 different language layouts to choose from: English, German, French, Spanish, Italian, Russian, Portugese, Polish, Finnish, Swedish, Chinese (pinyin) and Arabic were already in place, and now Hindi, Persian/Farsi, Danish and Norwegian (finally!) have been added. You can of course add more yourself. Next up on our roadmap are Japanese and Korean.

The keyboard supports both 5 and 2-way navigation, so you can also enter text through limited input devices, such as scroll wheel or joystick. As you have seen with previous versions, you can change the look of the keyboard, and now it is in addition possible to switch themes during runtime. For now it is only officially supported on embedded Linux,  embedded Android, and desktop Linux, but Windows support is coming up too. The documentation provides more details.

Qt Quick Enterprise Controls 1.2

Finally, the Tumbler is here! The Tumbler control is well-known in mobile user interfaces and much used in all kinds of touch-based devices. Now you no longer need to fiddle around manually with PathView & friends (as fun as it is, though!), but you can just take the Tumbler control and customize it into your needs!

Qt Quick Compiler 1.1

The Qt Quick Compiler, which was introduced with Qt 5.3.1, allows you to compile your otherwise-dynamically-loaded QML files into native code reducing load-time, enhancing performance on non-JITting platforms and making reverse engineering much harder. For embedded users this release brings robustness in form of multiple bug fixes.

Getting Started

Existing licensees for device creation with Qt can download the updated toolkit via Qt account or using their existing online installer. For new users, contact our sales to purchase a license or request a free 30-day trial via our Download page to get started with creating devices with Qt!

We are looking forward to your feedback!

The post Qt 5.3.2 Update for Device Creation appeared first on Qt Blog.