Async
Asynchronous programming is a neat tool, until you work with a foreign project in a foreign language using it. As a messenger, Dino uses lots of asynchronous code, not always though. Usually my progress wasn’t interfered by such instances, but sometimes I had to work around it.
Async in Vala
No surprises here.
Functions are annotated with async, and yield expressions that are asynchronous themselves.
And you can’t easily call async methods directly in non-async functions.
Creating problems
I had a async function I wanted to call in a synchronous context.
For quick prototyping, I wanted to call that function and get the result directly by blocking.
However, the furthest I got there was a variable in a function that is only initialized if you access it late enough (wouldn’t recommend).
At that point I restructured the code so that the async call would actually be in an async context with a simple yield.
Here a proper introduction to Vala async.
MetadataProvider
With the introduction of the metadata element, more metadata can be extracted from files and attached to file transfers. You wouldn’t have guessed, but there are actually a rather big variety of file types. So not only do different files use different metadata fields, but they can also use the fields in different ways.
To accommodate that relation, the FileManager module now keeps a list of FileMetadataProviders, which will be extended over time. When a file is sent, each provider is asked if it is compatible with the file. If yes, it is called. The first provider is a generic one which is called for every file and fills in name, last-edit-date, size, mime-type and hashes.
Thumbnail creation
A special new field is a list of thumbnails. They are intended for small previews of whichever file it is attached to, be it a image, video or pdf. So far, I have implemented thumbnails for images, which introduced two design decisions.
Size: Which dimensions should the preview have? When it is displayed, it should be stretched to the format of the original image, so the aspect ratio should sort of match. My mentor, larma, suggested that we create very small thumbnails for now, about 8 or 9 pixels. Which dimensions would that allow? 1x8, 2x4, 3x3, 4x2, 8x1. Well, that sounds pretty diverse, no? Those are the dimensions that we use for now, and I select the dimension with the closest aspect ratio.
Scaling: Now that we have the size, how do we scale the image? Luckily, Gtk (which Vala is closely integrated with), has scaling methods for images. So far, I used bilinear scaling, which is usually the suggested method according to the docs. However, scaling to such a small size results in a lot of gray. While you could probably come up with a fancy custom-made algorithm, I’ll stick with the Gtk built-in methods. Maybe nearest-neighbor could be a better choice, because it would show a ’true’ color from the original image.
UI
I tried to hold off on UI work until the last weeks of the projects.
While this could’ve easily been due to procrastination (I don’t enjoy UI coding a lot), I actually have a good excuse here.
The Dino codebase is being migrated to Gtk4 from Gtk3 this year.
Due to this, a lot of UI code is being rewritten, and it would’ve been wasted work to implement new UI elements in the old codebase.
The new UI element I introduced is the FilePreviewWidget, which holds a thumbnail of files which are so large that they aren’t immediately downloaded (currently >5 MB).
Luckily, the user interaction and graphical components are really close to the FileImageWidget and FileDefaultWidget, so the implementation wasn’t that difficult.
Progress
We are nearly finished. The one thing left is source attaching, which the next (and last) progress post will cover. Like always, you can track my progress on the stateless-file-sharing branch. I also created a pre-gtk4-rebase branch stateless-file-sharing-pre-gtk4.