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
.
