Jereme Givens-Lamothe

ZestyMeta: A pleasing arrangement of vowels and consonants.

github gitlab twitter linkedin
VTCC 2017 Followup
May 27, 2019
4 minutes read

I intended to followup my Vermont Code Camp 2017 post within a matter of weeks, but here we are nearly two years later. The talk covered it’s topic in the broadest of strokes in the briefest amount of time. Writing a technical post at any acceptable level of detail was just too intimidating. Throw in the inevitable “things got busy at work”, and suddenly it’s the summer of 2019.

Such a post would have begun with the basics, an introduction to Qt framework and Qt Quick. In retrospect, this topic alone would have been enough to fill the VTCC 2017 talk. Forget creating a custom HMI, I was creating entire desktop applications in a dozen lines of QML code! While not precisely the code displayed during the talk, it was more or less the complexity of the following:

import QtQuick 2.0
import QtQuick.Controls 2.0

Window {
    id: window
    visible: true; width 640; height: 480
    title: qsTr("My Application")

    Button {
    	text: qsTr("Click Me")
    	onClicked: console.log("Clicked!")
    }
}

This brought the talk to a screeching halt; I spent much of the remaining time answering questions about the code sample, rather than talking about the theoretical app platform. Their confusion was not due to difficulty in understanding the code, but in disbelief that I wasn’t hiding a bunch of boilerplate backend code somewhere. A teachable moment for myself, where I realized I had taken for granted my knowledge and experience with Qt / QML. My talk outline assumed an entire application framework was an obvious, quickly graspable atomic unit of knowledge, such that I could rush ahead to a 400s level elective course on creating an app platform. Madness! Naivety!

Our theoretical followup post, having comprehensively covered Qt Quick and now a half hour read, would continue on to introduce the Qt Application Manager. It’s a curious thing, not included as a module in the Qt framework, but instead as part of the Qt Automotive Suite. Best I can tell, it’s never been blogged about, or marketed independent of it’s automotive use-case origins. I’m at a loss as to why, as it’s an exceptional piece of technology available under both open source and commercial licenses.

At it’s core, the Qt Application Manager combines a Qt Wayland Compositor with an application launcher. It provides the foundation for sandboxing an executable in a container, and the tools to monitor resource usage by apps. Interprocess communication is made possible by a high level intents API, and low level D-Bus connectivity. Capabilities enable apps to declaratively state a whitelist of system features to access. Application distribution is accomplished through a packaging system, and ability to connect to external package repositories. Though not included with the open-source code, the commercial version comes with comprehensive tooling for development, debugging, and deploying to target hardware. It’s nearly everything you’d need to create the HMI for a mobile device, tablet, or automotive infotainment.

Assuming a desktop development environment with Qt, building appman is a simple matter of cloning the source code and running qmake + make. Downloading the official hello world example app, or the stopwatch example I demonstrated at VTCC 2017 will get you up and running. The Application Manager will happily launch in it’s own window in a desktop environment, and properly display launched apps within it. From experience, it’s possible to install Ubuntu Server (16.04 or later) on a vanilla x86 PC, build Qt with the eglfs platform plugin, and use the Qt Application Manager to create a custom desktop that launches on startup. I’d be willing to bet that either an Intel NUC or Raspberry Pi 3 could be put to some exciting use in a similiar manner.

Our imaginary followup blog post is now several hours in length, mobile browsers strain to render the text, and wandering minds lose interest as the scroll indicator shrinks to a pixel in height. It ends with a sigh and a shrug.

In closing, speaking at Vermont Code Camp 2017 was a great experience, both for the teachable moments as mentioned above, and for the opportunity to attend talks by others in beautiful Burlington, VT. The event has made tremendous leaps since I last attended in 2011. The location alone, now overlooking Lake Champlain from atop a hill, was a huge upgrade from the old basement classrooms on the UVM campus. I’m hoping to find an excuse to travel and attend again this coming year.


Back to posts