protonvpn in Libertine
Out of curiosity I tried to install protonvpn in Libertine container in the same way one would install it on Ubuntu Desktop. Protonvpn didn't work at all, showing loads of dbus related errors. Libertine runs in chroot according to python3 error messages, which apparently complicates a lot of systemd related things. Maybe it is not impossible to fix, but I kindly request more skilled developers to look at the errors protonvpn is throwing to figure out what to do about it.
Hopefully the protonvpn team realizes that they need to help out and make their software run also on Ubuntu Touch, not only regular Ubuntu, Debian, Fedora, openSUSE and Archlinux.
Secure FTPS server
I have seen discussions that there is a need for a solution where Ubuntu Touch offers some kind of server connectivity, like secure ftp with wifi hotspot so that another device can connect directly to Ubuntu Touch and share files. The Ubuntu Touch wifi hotspot serves as an access point for another device to obtain an ip address so that a connection to the server can be made with a ftps-client.
Here is a simple working python3 ftps-server example that can be installed in a Libertine container. It has been tested with Android app CX File Explorer which has an inbuilt ftps client located in the section on the right side NETWORK/New Location/REMOTE/FTP -> choose FTPS passive explicit mode:
FTPS server which works with Ubuntu Touch internal wifi hotspot
#!/usr/bin/env python3
"""
FTPS server with a simple switch to enable or disable pyftpdlib debug logging.
File name: start-ftps-server.py
Save this file in Libertine container folder:
mkdir $HOME/ftps_server
Make executable:
chmod +x start-ftps-server.py
Run ftps server:
./start-ftps-server.py [--debug]
or
python3 start-ftps-server.py [--debug]
Stop ftps server with Ctrl + C
Default ftps username: user
Default ftps password: 12345
Default port: 2222
Install dependencies:
apt-get install python3-pyftpdlib python3-netifaces python3-openssl
Create ftp directory:
mkdir $HOME/Downloads/ftp
Create self-signed certificates in the same directory as the ftps server:
cd $HOME/ftps_server
openssl req -x509 -newkey rsa:4096 -keyout keyfile.pem -out certfile.pem -days 365 -nodes
"""
import argparse
import logging
import netifaces
from pyftpdlib.authorizers import DummyAuthorizer
from pyftpdlib.handlers import TLS_FTPHandler
from pyftpdlib.servers import FTPServer
from OpenSSL import SSL
def parse_args():
parser = argparse.ArgumentParser(
description="Start a minimal FTPS server (pyftpdlib)."
)
parser.add_argument(
"--debug",
action="store_true",
help="Enable detailed pyftpdlib debug logging.",
)
return parser.parse_args()
def configure_logging(debug: bool):
level = logging.DEBUG if debug else logging.INFO
logging.basicConfig(
level=level,
format="%(asctime)s %(levelname)s %(message)s",
)
logging.getLogger("pyftpdlib").setLevel(level)
def get_current_ip() -> str | None:
for iface in netifaces.interfaces():
addrs = netifaces.ifaddresses(iface)
if netifaces.AF_INET not in addrs:
continue
for link in addrs[netifaces.AF_INET]:
ip = link.get("addr")
if ip and ip != "127.0.0.1":
return ip
return None
def create_ftps_server() -> FTPServer:
authorizer = DummyAuthorizer()
authorizer.add_user(
username="user",
password="12345",
homedir="/home/phablet/Downloads/ftp",
perm="elradfmwMT",
)
ctx = SSL.Context(SSL.TLS_METHOD)
ctx.use_certificate_file("/home/phablet/ftps_server/certfile.pem")
ctx.use_privatekey_file("/home/phablet/ftps_server/keyfile.pem")
handler = TLS_FTPHandler
handler.authorizer = authorizer
handler.allow_passive_mode = True
handler.passive_ports = range(60000, 65500)
handler.ssl_context = ctx
handler.tls_control_required = True
handler.tls_data_required = True
ip = get_current_ip()
if ip is None:
raise RuntimeError("No non‑loopback IPv4 address found.")
server = FTPServer((ip, 2222), handler)
return server
if __name__ == "__main__":
args = parse_args()
configure_logging(args.debug)
ftps = create_ftps_server()
host, port = ftps.socket.getsockname()
print(f"Starting FTPS server on {host}:{port} (debug={'on' if args.debug else 'off'})")
try:
ftps.serve_forever()
except KeyboardInterrupt:
print("\nServer stopped by user.")
except Exception as exc:
print(f"Server error: {exc}")
Conclusions from desktop mode tests
As you may see, most software that you find on a linux desktop does actually run well enough on Ubuntu Touch, although inside Libertine container. You can get most things done that you normally would use a desktop, laptop or notebook for.
The absolute biggest headache is the difficulty to get copy-paste to work well between all windows, especially to and from LibreOffice.
Screenshot functionality like xfce4-screenshooter or gnome-screenshot is wanted. It is used to grab a single window or to select a region and save it, or copy the screenshot directly into a chat. Printscreen key on a regular wired PS2 keyboard takes a screenshot of the whole screen and saves it in ~/Pictures/screenshots. I didn't get xfce4-screenshooter or gnome-screenshot to work as intended.
Automated, simple VPN that regularly adjusts parameters and autoselects a good node is probably wanted by some users. An example of that would be the functionality of protonvpn, which exists on Android and linux desktops.
Ability to control random MAC-addresses on public wifi networks is wanted. I read somewhere that Ubuntu Touch offers some privacy concerned MAC-address shifting when moving between public wifi networks, but it would be nice to get this verified by someone who knows more about how it works in detail.
I think that Ubuntu Touch with Libertine can be used as a PC, a linux desktop, already now. It passed the test to be considered good enough. Once the copy-paste functionality works to satisfaction, it will be many user's choice.
If the device supports USB3.0 display out so that you can connect Ubuntu Touch to an external monitor, mouse/touchpad, keyboard and external harddisk or pendrive, you really get the PC experience already in my opinion as a newbie myself.
For USB2.0 devices, it would be good to know exactly what is needed to connect to needed periferals including a monitor and compare the cost to a device which offers USB3.0 display out.
I have come to understand that the USB-port is used quite a lot more than one expects, which makes it the most sensitive part that eventualy will stop working at some point.
RAM memory 6GB seems to be enough for all the use cases I went through. Most of the time I see 2.5-4.2 GiB RAM used, with the absolute top at 5.9 GiB. Thunderbird and Firefox do not eat as much RAM as I thought they would do.
Hopefully these use cases give readers a bit more feeling for what Ubuntu Touch in desktop mode can offer at the present, using snaps and Libertine container. It gets better each day, as more and more users start to experiment with it and share their findings.
Conclusions about native mode
Desktop mode on a 24 inch monitor offers several ways to increase text sizes so that people with not perfect eyesight can adjust the zoom.
The native mode when using the mobile device screen by itself does not offer as much scaling capability as the desktop mode without messing up the look and feel. As a consequence, it may at times be quite difficult to see miniature text smaller than 1mm without a magnifying glass.
If Ubuntu Touch is meant for a larger target group, each app has to implement text scaling capabilities so that text can be shown bigger for those who need it without ruining the functionality of the app. Preferably, the text size settings should be set in Ubuntu Touch settings on a global level, which are then used by each app to show the text in the desired size. Android has this functionality from very early versions and new Ubuntu Touch users are going to look for these text scaling settings in the Ubuntu Touch settings.
I think users would benefit from an app naming convention that clearly indicates if a native Ubuntu Touch app is supposed to run in desktop mode for improved visibility. As an example, Linphone that is usable on a device screen size five or six inches should be called Linphone. Linphone-Desktop clearly indicates that the app needs desktop mode for visibility reasons. Every app meant to be used on the device without desktop mode should be able to display large text for better visibiltiy without falling over the edge. Another example: Brave browser should be visible and usable on a small screen, otherwise it should be called Brave-Desktop to indicate that you need desktop mode to use the app for better visibility. Yet another example: Thunderbird should be usable on a small screen versus Thunderbird-Desktop which is supposed to be used in desktop mode for greater visibility. Preferably, an app should be able to be useful and have visible text on a small screen as well as in a scaled-up desktop mode.
