When I started using Ubuntu Touch, I started developing a document scanner app called Camera Scanner out of curiosity. It turned out I am much more interested into the tooling than app development itself. Many features I contributed to Clickable were inspired by my work on this app while the Camera Scanner only made some progress thanks to contributions from friends (Stefan, Krille, Cibersheep). It reached a state where it kind of works, but not very reliably and with little feedback to the user, making the user experience rather frustrating.

I would love if somebody would be motivated to put love into the Camera Scanner App to make it the great app it could be. If someone would want to "only" take care of the frontend, I'd still be available to put some more work into the backend.

The backend is mostly a C++ reimplementation of the Open Note Scanner backend (written in Java), but less configurable (yet). It makes use of OpenCV for image processing.

I think the biggest hassle in the short run is neither packaging nor the store, but the QML framework and System Integration. It is not too hard to have different packaging configurations in your repo and deploy to different stores.

Pure Maps by @rinigus is a great example on how platform independent mobile linux apps can be done. The most interesting part is the platform abstraction in QML, in my opinion. The app assumes some QML files in a folder called platform, which is just an imaginary interface to Elements like a Button, a Dialog, Clipboard or file chooser (aka Content Hub in UT). Adding support to another platform means to create a new platform folder and implement the interface using the specific platform frameworks stuff. The packager then just links the desired platform folder to platform and builds the app.

Now you may wonder whether it is necessary for each and every app developer to implement each platform support over and over again. And of course it is not. That could be done in one place shared by all apps. Someone has already started that meta-framework-project as a spin-off from Pure Maps, which just needs to be explored and picked up by app developers.

Sure, this won't solve all problems like (push) notification and background services. But it should help a majority of all apps to become available on many platforms.

Marius mentioned he documented how to build the Lomiri stack in the last Q&A. Are those notes available somewhere already?

I didn't touch the README. You downloaded the old 15.04 version. Please build the app for 16.04 using Clickable instead. I don't plan to maintain the app, just wanted to show it is still mostly functional, in case anyone wants to pick it up.

It still works well on Ubuntu Touch. I added a clickable.json and changed the framework to 16.04: https://gitlab.com/jonnius/scriptor
If someone is interested in maintaining the app, please just fork the repo and release it to the OpenStore. The README needs to be cleaned up and the busybox download in app does not seem to work. But I don't think it is even necessary, so maybe it could just be removed.

• There is a brain dump by Marius, where he started with Raspbian.
• There are official Ubuntu Core images
• There are some unofficial Ubuntu server images
• There is also Ubuntu Mate 16.04 for Raspberry Pi

What would be the best to start with?

Clickable supports Focal Desktop Mode starting from 7.4.0. So app developers can try whether their apps compile and start without crash on focal.
CLICKABLE_FRAMEWORK=ubuntu-sdk-20.04 clickable desktop
Until some compatibility layer is in place (its planned), one needs to change Ubuntu QML imports:
find -name '*.qml' | xargs -I {} sed -i 's/import Ubuntu\./import Lomiri./g' {}

Dear Dalton. Thank you very much for all the hard work. The community wouldn't be what it is today without you. You can be proud of it. And honestly, you have exceeded my expectations. From the bottom of my heart i wish you to recover and find profound joy again. God bless you!

You got the right approach already. Clickable does not require any specific project structure. Ideally you would just add a clickable config (clickable.json) and a few UT specific files (manifest, apparmor config, maybe a specific desktop file), see Pure Maps for example. Only the folder packaging/click is UT specific.

I would go step by step like this:

• add a simple clickable.json with builder set to qmake
• run clickable build -a amd64 and see what happens
  • you might need to set some build_args that would be consumed by QMake
  • you will probably need to add dependencies to the build container (dependencies_target and dependencies_host for build tools)
  • for dependencies that are not available in the ubuntu repos, you already mentioned the libraries feature. Refer to this guide for details
• Once it builds the app, you can start with what is needed for the click package
  • Create a new app with clickable create filling in the details
  • Copy over the manifest.json.in, rename it to manifest.json and just put fix values where there are placeholders.
  • Copy over the the apparmor file and add policies if needed.
  • For the desktop file I would look for one in the build or source dir, copy it over and add the line X-Ubuntu-Touch=true.
  • Add those 3 files to install_data.
  • Try first in Desktop Mode with clickable desktop and then on the device clickable chain build install launch logs -a arm64 # or armhf

Just for calification: click is the package format that Ubuntu Touch expects. The tool to create such a package is called click, too (but you don't use that one directly if using Clickable). Clickable is a tool that knows how to handle click, do cross compiling utilizing docker (Clickable also provides the necessary images), handle build tools like CMake, QMake or cargo, run apps in Desktop Mode, handle some debugging tools like gdb, configure an IDE, install a click on your device and so on. So it is like a swizz knife for UT app development...

Fluffy Chat Flutter is the cross-platform version of Fluffy Chat, providing full E2E support and being actively developed. The QML version of Fluffy Chat will only be maintained on a low level until Fluffy Chat Flutter works on Ubuntu Touch as well (requiring Wayland support afaik), which will make the QML version completely obsolete.

Unfortunately the QML version we have at the moment does not support E2E. As the airport in Berlin is coming close to be opened, we want to provide you with a temporary solution: Pantalaimon.

Pantalaimon is provided by the Matrix Foundation and described as:

Pantalaimon is an end-to-end encryption aware Matrix reverse proxy daemon. Pantalaimon acts as a good man in the middle that handles the encryption for you.

Messages are transparently encrypted and decrypted for clients inside of pantalaimon.

You can find instructions as well as possible next steps in my repository. Feel free to test, provide feedback and jump in to improve it.

Update: Source code and releases: https://sr.ht/~thrrgilag/pantalaimon-ut/

Citing rinigus:

GPX Smart is designed to take your regular GPX trace and add navigation instructions to it (like "turn right in ..."). If you just have 2 points, set one of them as origin and the other one as destination and calculate the route

Note that as GPX Smart matches your GPX trace to road network it will depend on all kind of restrictions. Those include whether car can go through, direction of the street. Sometimes it breaks when you take your walking GPX trace and try to fit with car GPX smart, for obvious reasons

PS: For more direct ways to give feedback or get help with Pure Maps, see User Feedback.

Clickable supports Focal Desktop Mode starting from 7.4.0. So app developers can try whether their apps compile and start without crash on focal.
CLICKABLE_FRAMEWORK=ubuntu-sdk-20.04 clickable desktop
Until some compatibility layer is in place (its planned), one needs to change Ubuntu QML imports:
find -name '*.qml' | xargs -I {} sed -i 's/import Ubuntu\./import Lomiri./g' {}

I still don't understand why you want to compile Godot instead of just using the one we ship in the build containers. But if you want to do so, see abmyii's build script (https://gitlab.com/abmyii/ubports-godot/-/blob/v3.4.0-ubports/build-ubports.sh) which he runs without Clickable, but within a clickable container (https://gitlab.com/abmyii/ubports-godot/-/blob/v3.4.0-ubports/.gitlab-ci.yml).

If you are just interested in cross compiling with Clickable in general, that is pretty straight forward. The build containers are set up in a way that you only need to tell Clickable which architecture to build for and Clickable chooses the according prepared build container. If you are interested how they are set up, see the Dockerfile: https://gitlab.com/clickable/clickable-docker-images/-/blob/master/ubuntu-sdk/16.04-cross-build/Dockerfile.

And finally, if you want to compile dependencies along with you app, see this guide: https://docs.ubports.com/en/latest/appdev/guides/dependencies.html

To facilitate the process, we have added abmyii's Godot builds to the Clickable build containers. You can directly install it into the click package. Check out the clickable.yaml in the Godot template you get with clickable create.

Dear Dalton. Thank you very much for all the hard work. The community wouldn't be what it is today without you. You can be proud of it. And honestly, you have exceeded my expectations. From the bottom of my heart i wish you to recover and find profound joy again. God bless you!

Looking at their required dependencies you might get somewhere. But do you know whether their UI is optimized for small touch screens?

You got the right approach already. Clickable does not require any specific project structure. Ideally you would just add a clickable config (clickable.json) and a few UT specific files (manifest, apparmor config, maybe a specific desktop file), see Pure Maps for example. Only the folder packaging/click is UT specific.

I would go step by step like this:

• add a simple clickable.json with builder set to qmake
• run clickable build -a amd64 and see what happens
  • you might need to set some build_args that would be consumed by QMake
  • you will probably need to add dependencies to the build container (dependencies_target and dependencies_host for build tools)
  • for dependencies that are not available in the ubuntu repos, you already mentioned the libraries feature. Refer to this guide for details
• Once it builds the app, you can start with what is needed for the click package
  • Create a new app with clickable create filling in the details
  • Copy over the manifest.json.in, rename it to manifest.json and just put fix values where there are placeholders.
  • Copy over the the apparmor file and add policies if needed.
  • For the desktop file I would look for one in the build or source dir, copy it over and add the line X-Ubuntu-Touch=true.
  • Add those 3 files to install_data.
  • Try first in Desktop Mode with clickable desktop and then on the device clickable chain build install launch logs -a arm64 # or armhf

Just for calification: click is the package format that Ubuntu Touch expects. The tool to create such a package is called click, too (but you don't use that one directly if using Clickable). Clickable is a tool that knows how to handle click, do cross compiling utilizing docker (Clickable also provides the necessary images), handle build tools like CMake, QMake or cargo, run apps in Desktop Mode, handle some debugging tools like gdb, configure an IDE, install a click on your device and so on. So it is like a swizz knife for UT app development...

@thrrgilag would it be easy to include panctl into the click so that people could verify the device on command line at least? I see that it gets built with pantalaimon already, but not packaged.

@keneda thanks. I hope so, too.

When I started using Ubuntu Touch, I started developing a document scanner app called Camera Scanner out of curiosity. It turned out I am much more interested into the tooling than app development itself. Many features I contributed to Clickable were inspired by my work on this app while the Camera Scanner only made some progress thanks to contributions from friends (Stefan, Krille, Cibersheep). It reached a state where it kind of works, but not very reliably and with little feedback to the user, making the user experience rather frustrating.

I would love if somebody would be motivated to put love into the Camera Scanner App to make it the great app it could be. If someone would want to "only" take care of the frontend, I'd still be available to put some more work into the backend.

The backend is mostly a C++ reimplementation of the Open Note Scanner backend (written in Java), but less configurable (yet). It makes use of OpenCV for image processing.