Displaying Images

Search…
Displaying Images
Displaying Album Cover Images
So we have the Albums showing with the Artist name and Title, however if we can download the Album art and display it, this will really bring the app alive.
Fortunately our buisness logic code provides a convenient LoadCoverBitmapAsync this returns a stream that can be used to load a bitmap from.
Firstly open AlbumViewModel.cs and add a property of type Bitmap? named Cover using the common pattern so that it can notify the UI when it changes. You will need a using Avalonia.Media.Imaging; directive to do so.
1
private Bitmap? _cover;
2
​
3
public Bitmap? Cover
4
{
5
    get => _cover;
6
    private set => this.RaiseAndSetIfChanged(ref _cover, value);
7
}
Copied!
Next we need to actually load the image data. To do this add the following method.
1
public async Task LoadCover()
2
{
3
    await using (var imageStream = await _album.LoadCoverBitmapAsync())
4
    {
5
        Cover = await Task.Run(() => Bitmap.DecodeToWidth(imageStream, 400));
6
    }
7
}
Copied!
Notice that it uses a Task to run the Bitmap loading on a background thread, this is so that the UI thread does not get blocked and make the UI unresponsive, potentially we will be loading many images quickly.
We also use the Bitmap.DecodeToWidth method to create a Bitmap object. This is an important insight, if you want to display images in your UI and the jpg, png or whatever format you using provides a very large hight resolution image, but you only want to display it in a small portion of your UI. You need to decode the image so that the Bitmap this is displayed is not the full resolution. This DecodeToWidth method maintains the aspect ratio and loads to the specified width, efficiently. This means we will not waste huge amounts of memory to show our album covers even if the image files themselves turn out to be quite large.
Now we need to start loading the Album covers whenever a search query has been returned from the backend. Note that because loading the images takes time and is asynchronous, we may need to cancel loading them if the user makes another search request.
Your AlbumViewModel.cs should now look like:
1
using Avalonia.Media.Imaging;
2
using Avalonia.MusicStore.Models;
3
using ReactiveUI;
4
​
5
namespace Avalonia.MusicStore.ViewModels
6
{
7
    public class AlbumViewModel : ViewModelBase
8
    {
9
        private readonly Album _album;
10
        private Bitmap? _cover;
11
​
12
        public AlbumViewModel(Album album)
13
        {
14
            _album = album;
15
        }
16
​
17
        public string Artist => _album.Artist;
18
​
19
        public string Title => _album.Title;
20
​
21
        public Bitmap? Cover
22
        {
23
            get => _cover;
24
            private set => this.RaiseAndSetIfChanged(ref _cover, value);
25
        }
26
​
27
        public async Task LoadCover()
28
        {
29
            await using (var imageStream = await _album.LoadCoverBitmapAsync())
30
            {
31
                Cover = await Task.Run(() => Bitmap.DecodeToWidth(imageStream, 400));
32
            }
33
        }
34
    }
35
}
Copied!
Open MusicStoreViewModel.cs and add the following method.
1
private async void LoadCovers(CancellationToken cancellationToken)
2
{
3
    foreach (var album in SearchResults.ToList())
4
    {
5
        await album.LoadCover();
6
​
7
        if (cancellationToken.IsCancellationRequested)
8
        {
9
            return;
10
        }
11
    }
12
}
Copied!
Calling this asynchronous method will itereate through each item in a copy of the SearchResults and call our AlbumViewModels LoadCover method. Creating a copy with .ToList() is necessary because this method is async and SearchResults might be updated by another thread.
Notice a CancellationToken is used to check if we want to stop loading album covers.
Now add the following code to the beggining of DoSearch method of MusicStoreViewModel after the SearchResults.Clear(); line.
1
_cancellationTokenSource?.Cancel();
2
_cancellationTokenSource = new CancellationTokenSource();
3
var cancellationToken = _cancellationTokenSource.Token;
Copied!
If there is an existing request still loading Album art, we can cancel it. Because _cancellationTokenSource might be replaced asynchronously we have to store the cancellation token in a local variable.
Now add the following code to the end of DoSearch method of MusicStoreViewModel after the foreach loop.
1
if (!cancellationToken.IsCancellationRequested)
2
{
3
    LoadCovers(cancellationToken);
4
}
Copied!
DoSearch should now look like this.
1
private async void DoSearch(string s)
2
{
3
    IsBusy = true;
4
    SearchResults.Clear();
5
​
6
    _cancellationTokenSource?.Cancel();
7
    _cancellationTokenSource = new CancellationTokenSource();
8
    var cancellationToken = _cancellationTokenSource.Token;
9
​
10
    if (!string.IsNullOrWhiteSpace(s))
11
    {
12
        var albums = await Album.SearchAsync(s);
13
​
14
        foreach (var album in albums)
15
        {
16
            var vm = new AlbumViewModel(album);
17
​
18
            SearchResults.Add(vm);
19
        }
20
​
21
        if (!cancellationToken.IsCancellationRequested)
22
        {
23
            LoadCovers(cancellationToken);
24
        }
25
    }
26
​
27
    IsBusy = false;
28
}
Copied!
Ok run the application and search for your favourite artist.
Notice how the Albums covers load one by one, but that the UI remains responsive.
image-20210310173858088
Searching for Albums
Add Items to Users Collection
Last modified 19d ago
Export as PDF
Copy link