Learn how to create a simple chat page UI that could be used for real-time message exchange, with support for images.

TLDR: Click here to check a fully working sample with support for Android, iOS and WinUI.

Objective

Create a chat like interaction, where we can send and receive images and text. Here are some ideas of what it could look like:

Approach used and why I used it

I tried reducing the external dependencies to a minimum, so I used the native controls offered out-of-the-box by .NET MAUI. I did however use the community toolkit nugets to be able to simplify the code and zoft.MauiExtensions.Core nuget package for some useful extensions.
The initial project was created using the MAUI App Accelerator extension by Matt Lacey

In a first approach I though about using the CollectionView with the grouping feature but as it turned out, this approach works very well for Android, but has known UI rendering issues on iOS. To workaround this problem, I choose to use a single list of items, that contain 2 types of objects (MessageGroupand MessageItem)

public class MessageGroup(string name)
{
    public string Name { get; } = name;
}

public class MessageItem
{
    public string? Body { get; set; }

    public DateTime Created { get; set; }

    public bool IsMyMessage { get; set; }

    public List<MediaItem> Attachments { get; set; } = [];
}

Implementation

Start by creating a new project (I used the MAUI App Accelerator extension by Matt Lacey).

I’ll skip the formalities of adding the backbone code and keep focused on the UI of the chat itself. You can take a look at the different components added, in the the github repo here. Here’s an overview of what was added:
 — Converters to help format the time.
 — Models that represent a message, a message group and a media item (image).
 — Services that provides a mocked logic for sending and receiving messages.
 — ViewModels to support the chat page functionality.
 — Views that contain all the UI implementation.

Now let’s talk about the UI.
The main piece will be the ChatPage. This page will have a CollectionView to show the messages. Bellow that list there will be an area for the controls to write a message, attach images and send the message. Finally at the bottom, there will be an area to show the images that are attached to the message that will be sent.

Messages List

The CollectionView configuration will be quite simple. It will have a list of messages, bound to the ItemsSource and an ItemTemplate bound to a MessageTemplateSelector.

<!-- Messages List -->
<CollectionView x:Name="MessagesList" 
                ItemsSource="{Binding GroupedMessages}"
                ItemTemplate="{StaticResource MessageTemplateSelector}"
                ItemsUpdatingScrollMode="KeepLastItemInView"
                Grid.Row="0">
    <CollectionView.ItemsLayout>
        <LinearItemsLayout Orientation="Vertical"
                           ItemSpacing="5" />
    </CollectionView.ItemsLayout>
</CollectionView>

The MessageTemplateSelector will have 3 templates to choose from: MessageGroupTemplate, MessageSentTemplate and MessageReceivedTemplate.

<DataTemplate x:Key="MessageGroupHeaderTemplate">
    <v:MessageGroupHeaderTemplate/>
</DataTemplate>

<DataTemplate x:Key="MessageSentTemplate">
    <v:MessageSentTemplate/>
</DataTemplate>

<DataTemplate x:Key="MessageReceivedTemplate">
    <v:MessageReceivedTemplate/>
</DataTemplate>

<v:MessageTemplateSelector x:Key="MessageTemplateSelector"
                           GroupHeader="{StaticResource MessageGroupHeaderTemplate}"
                           MessageSent="{StaticResource MessageSentTemplate}"
                           MessageReceived="{StaticResource MessageReceivedTemplate}" />

public class MessageTemplateSelector : DataTemplateSelector
{
    public DataTemplate GroupHeader { get; set; } = null!;

    public DataTemplate MessageSent { get; set; } = null!;
    
    public DataTemplate MessageReceived { get; set; } = null!;


    protected override DataTemplate OnSelectTemplate(object item, BindableObject container)
    {
        if (item is MessageGroup)
        {
            return GroupHeader;
        }

        return ((MessageItem)item).IsMyMessage ? MessageSent : MessageReceived;
    }
}

<!-- MessageGroupHeaderTemplate -->
<Grid xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
      xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
      x:Class="MauiChat.Views.MessageGroupHeaderTemplate"
      xmlns:m="clr-namespace:MauiChat.Models"
      x:DataType="m:MessageGroup">

    <Grid.Resources>

        <Style x:Key="GroupBubbleStyle" TargetType="Border">
            <Setter Property="BackgroundColor" Value="#b7babb" />
            <Setter Property="StrokeShape" Value="RoundRectangle 15" />
            <Setter Property="Padding" Value="5" />
            <Setter Property="Margin" Value="5" />
            <Setter Property="HorizontalOptions" Value="Center" />
            <Setter Property="VerticalOptions" Value="Center" />
        </Style>
        
    </Grid.Resources>

    <Border Style="{StaticResource GroupBubbleStyle}">
        <Label Text="{Binding Name}"/>
    </Border>

</Grid>

<!-- MessageReceivedTemplate -->
<Grid xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
      xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
      x:Class="MauiChat.Views.MessageReceivedTemplate"
      xmlns:converters="clr-namespace:MauiChat.Converters"
      xmlns:m="clr-namespace:MauiChat.Models"
      x:DataType="m:MessageItem"
      ColumnDefinitions="10,.8*,.2*">
 
    <Grid.Resources>
 
        <converters:MessageDateConverter x:Key="MessageDateConverter" />
        
        <Color x:Key="PeerMessageBackgroundColor">#DDDDDD</Color>
        <Color x:Key="MessagesTextColor">#DE000000</Color>
        
    </Grid.Resources>
 
    <Grid Grid.Column="0"
          Margin="0,0,0,5"
          VerticalOptions="End">
        
        <Polygon Points="0,10 10,0 10,20"
                 StrokeThickness="0"
                 Fill="{StaticResource PeerMessageBackgroundColor}" />
    </Grid>
 
    <Border Grid.Column="1"
            StrokeShape="RoundRectangle 5"
            StrokeThickness="0"
            BackgroundColor="{StaticResource PeerMessageBackgroundColor}">
        
        <Grid RowDefinitions="Auto,Auto,Auto"
              ColumnDefinitions="*,Auto"
              Padding="10,5,5,5">
 
            <Label Text="Another person"
                   TextColor="{StaticResource MessagesTextColor}"
                   Grid.Row="0"
                   FontAttributes="Bold" />
 
            <Grid Grid.Row="1"
                  RowDefinitions="Auto,Auto"
                  RowSpacing="6">
                
                <Label Text="{Binding Body}"
                       TextColor="{DynamicResource MessagesTextColor}"
                       Grid.Row="0"/>
 
                <FlexLayout BindableLayout.ItemsSource="{Binding Attachments}"
                            Grid.Row="1"
                            Style="{StaticResource FlexLayoutImageContainerStyle}">
                    <BindableLayout.ItemTemplate>
                        <DataTemplate x:DataType="m:MediaItem">
                            <Image Source="{Binding Source}" Style="{StaticResource ImageSmallStyle}" />
                        </DataTemplate>
                    </BindableLayout.ItemTemplate>
                </FlexLayout>
            </Grid>
 
            <Label Grid.Row="2"
                   Grid.Column="1"
                   Text="{Binding Created, Converter={StaticResource MessageDateConverter}}"
                   TextColor="{DynamicResource MessagesTextColor}"/>
        </Grid>
    </Border>
 
</Grid>

<!-- MessageSentTemplate -->
<Grid xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
      xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
      x:Class="MauiChat.Views.MessageSentTemplate"
      xmlns:converters="clr-namespace:MauiChat.Converters"
      xmlns:m="clr-namespace:MauiChat.Models"
      x:DataType="m:MessageItem"
      ColumnDefinitions=".2*,.8*,15">
 
    <Grid.Resources>
 
        <converters:MessageDateConverter x:Key="MessageDateConverter" />
 
        <Color x:Key="MyMessageBackgroundColor">#5C809D</Color>
        <Color x:Key="MessagesTextColor">#FFFFFF</Color>
        
    </Grid.Resources>
    
    <Border Grid.Column="1"
            StrokeShape="RoundRectangle 5"
            StrokeThickness="0"
            BackgroundColor="{StaticResource MyMessageBackgroundColor}">
        
        <Grid RowDefinitions="Auto,Auto,Auto"
              ColumnDefinitions="*,Auto"
              Padding="10,5,5,5">
 
            <Label Text="Myself"
                   TextColor="{StaticResource MessagesTextColor}"
                   Grid.Row="0"
                   FontAttributes="Bold"/>
 
            <Grid Grid.Row="1"
                  RowDefinitions="Auto,Auto"
                  RowSpacing="6">
                <Label Text="{Binding Body}"
                       TextColor="{StaticResource MessagesTextColor}"
                       Grid.Row="0"/>
 
                <FlexLayout BindableLayout.ItemsSource="{Binding Attachments}"
                            Grid.Row="1"
                            Style="{StaticResource FlexLayoutImageContainerStyle}">
                    <BindableLayout.ItemTemplate>
                        <DataTemplate x:DataType="m:MediaItem">
                            <Image Source="{Binding Source}" Style="{StaticResource ImageSmallStyle}" />
                        </DataTemplate>
                    </BindableLayout.ItemTemplate>
                </FlexLayout>
            </Grid>
 
            <Label Grid.Row="2"
                   Grid.Column="1"
                   Text="{Binding Created, Converter={StaticResource MessageDateConverter}}"
                   TextColor="{StaticResource MessagesTextColor}" />
        </Grid>
    </Border>
 
    <Grid Grid.Column="2"
          Margin="0,0,0,5"
          VerticalOptions="End">
        <Polygon Points="0,0 0,20 10,10"
                 StrokeThickness="0"
                 Fill="{StaticResource MyMessageBackgroundColor}" />
    </Grid>
    
</Grid>

Controls Area

This area provides the interaction controls to write a text message and to add attachments.

<!-- Message Input -->
<Grid Grid.Row="1"
      ColumnDefinitions="*,Auto"
      IsEnabled="{Binding IsSendingMessage, Converter={StaticResource InvertedBoolConverter}}">

    <Border Grid.Column="0"
            StrokeShape="RoundRectangle 20"
            Margin="6">
        <Grid ColumnDefinitions="*,Auto,Auto"
              ColumnSpacing="6"
              Margin="6,0,6,0">

            <Editor Grid.Column="0"
                    Placeholder="Write your message..."
                    Text="{Binding MessageBody, Mode=TwoWay}"
                    AutoSize="TextChanges"
                    MaximumHeightRequest="100"
                    VerticalOptions="Center"/>

            <Button Style="{StaticResource ActionButtonStyle}"
                    Command="{Binding TakePhotoCommand}"
                    IsVisible="{Binding IsTyping, Converter={StaticResource InvertedBoolConverter}}"
                    Grid.Column="1">
                <Button.ImageSource>
                    <FontImageSource FontFamily="{x:Static root:IconFontFamily.MaterialIcons}"
                                     Glyph="{x:Static root:IconFontGlyph.Photo_camera}"
                                     Size="{StaticResource FontIconDefaultSize}"
                                     Color="{StaticResource FontIconDefaultColor}"/>
                </Button.ImageSource>
            </Button>

            <Button Style="{StaticResource ActionButtonStyle}"
                    Command="{Binding PickPhotoCommand}"
                    IsVisible="{Binding IsTyping, Converter={StaticResource InvertedBoolConverter}}"
                    Grid.Column="2">
                <Button.ImageSource>
                    <FontImageSource FontFamily="{x:Static root:IconFontFamily.MaterialIcons}"
                                     Glyph="{x:Static root:IconFontGlyph.Image}"
                                     Size="{StaticResource FontIconDefaultSize}"
                                     Color="{StaticResource FontIconDefaultColor}"/>
                </Button.ImageSource>
            </Button>
        </Grid>
    </Border>

    <Button Style="{StaticResource SendButtonStyle}"
            Command="{Binding SendMessageCommand}"
            IsVisible="{Binding IsSendingMessage, Converter={StaticResource InvertedBoolConverter}}"
            Grid.Column="1">
        <Button.ImageSource>
            <FontImageSource FontFamily="{x:Static root:IconFontFamily.MaterialIcons}"
                             Glyph="{x:Static root:IconFontGlyph.Send}"
                             Size="24"/>
        </Button.ImageSource>
    </Button>

    <ActivityIndicator Style="{StaticResource ActivityIndicatorStyle}"
                       IsVisible="{Binding IsSendingMessage}"
                       IsRunning="True"
                       Grid.Column="1" />
</Grid>

Attachments

This area will show a list of the attached images.

<!-- Attachments List -->
<Grid Grid.Row="2" RowDefinitions="Auto"
      IsEnabled="{Binding IsSendingMessage, Converter={StaticResource InvertedBoolConverter}}"
      IsVisible="{Binding MessageAttachments, Converter={StaticResource IsListNotNullOrEmptyConverter}}"
      MaximumHeightRequest="150">
    <ScrollView VerticalOptions="Fill" HorizontalOptions="Fill" HeightRequest="150">
        <FlexLayout BindableLayout.ItemsSource="{Binding MessageAttachments}"
                    Style="{StaticResource FlexLayoutImageContainerStyle}">
            <BindableLayout.ItemTemplate>
                <DataTemplate x:DataType="m:MediaItem">
                    <Image Source="{Binding Source}"
                           Style="{StaticResource ImageStyle}">
                        <Image.GestureRecognizers>
                            <TapGestureRecognizer Command="{Binding Source={Reference self},
                                                            Path=BindingContext.RemoveAttachmentCommand}" 
                                                  CommandParameter="{Binding .}"/>
                        </Image.GestureRecognizers>
                    </Image>
                </DataTemplate>
            </BindableLayout.ItemTemplate>
        </FlexLayout>
    </ScrollView>
    
</Grid>

ScrollToBottom behaviour

As an extra behavior, I also wanted to had the possibility to Scroll-To-Bottom. This interaction should be done via a button that is shown, when we’re not already at the bottom of the messages list.

The button UI implementation is quite simple. We just show an ImageButton on top of the messages list.

<!-- GoToBottom Button -->
<ImageButton Grid.Row="0"
             Style="{StaticResource ScrollToBottomImageButtonStyle}"
             Clicked="ButtonScrollToBottom_Clicked"
             x:Name="ButtonScrollToBottom">
    <ImageButton.Source>
        <FontImageSource FontFamily="{x:Static root:IconFontFamily.MaterialIcons}"
                         Glyph="{x:Static root:IconFontGlyph.Keyboard_double_arrow_down}"
                         Size="{StaticResource FontIconDefaultSize}"/>
    </ImageButton.Source>
</ImageButton>

To control the visibility and functionality of the button, we use the CollectionView.Scrolled event to check if the last item of the list is visible and act accordingly. We then use the CollectionView.ScrollTo method to force the list to show a specific item (in this case, the last one)

private void MessagesList_Scrolled(object? sender, ItemsViewScrolledEventArgs e)
{
    ButtonScrollToBottom.IsVisible = e.LastVisibleItemIndex != ViewModel.GroupedMessages.Count - 1;
}

private void ButtonScrollToBottom_Clicked(object sender, EventArgs e)
{
    MessagesList.ScrollTo(ViewModel.GroupedMessages.Count - 1);
}

And that’s it! The chat page is ready to be used!

After the amazing posts written during this year’s #MAUIUIJULY I felt that I could also give my small contribution the the .NET MAUI community. Let me know if you liked the approach and what would you change.

Happy Coding!

How to create a simple chat page using .NET MAUI was originally published in Medialesson on Medium, where people are continuing the conversation by highlighting and responding to this story.

Learn how to solve the interactivity issues, on iOS, when using the .NET MAUI Community Toolkit DrawingView inside a scrollable layout.

TLDR: Click here to check a fully working sample that has the fix for the problem explained and solved on this post.

The problem

If you have used the DrawingView control, from .NET MAUI Community Toolkit in your iOS apps, you might have come across an issue where it becomes difficult to interact with it, because the touch event is being captured by another control. This issue happens when the DrawingView control is wrapped by a scrollable layout (eg. ScrollView, TableView). (See GitHub issue)

The explanation

This issue is caused by a specific behavior that exists on iOS. There is an implicit timer when a touch gesture begins in an UIScrollView, that is used by the platform to decide what to do with that gesture based on user action (see here). This timer is causing the gesture to be passed on to the ScrollView instead of the DrawingView control.

The solution

Good news is, that the UIScrollView control on iOS has a property called DelaysContentTouches that allows the developer to decide if such a delay timer should be used or not. By default this property is set to true, so we’ll need to explicitly disable it.

NOTE: I’ll show you how you can solve this issue when using a ScrollView and TableView. If you’re using a different type of scrollable layout in your .NET MAUI app, the solution might be similar, so continue reading !

Fix for ScrollView
You can use an extension provided by .NET MAUI that allows you to directly control the value of the DelaysContentTouches.

<ContentPage
    xmlns:ios="clr-namespace:Microsoft.Maui.Controls.PlatformConfiguration.iOSSpecific;assembly=Microsoft.Maui.Controls">

    <ScrollView ios:ScrollView.ShouldDelayContentTouches="false">

        <DrawingView />

    </ScrollView>

</ContentPage>

Fix for TableView
The extension to manipulate the DelaysContentTouches works specifically for ScrollView, so we’ll need to do a bit more work to solve the issue for TableView.
There are two possible solutions I can think of:
- create a specific extension for TableView
OR
- override the renderer of the TableView

I’ll show you the renderer approach, so that will get you going.

If you take a closer look at the implementation of the TableViewRenderer for iOS, you’ll notice that the TableView is mapped to a UITableView. Furthermore, the UITableView is a subclass of UIScrollView, which means that it also has the same DelaysContentTouches property!

We just need to override the renderer and set this property to true!

public class MyTableViewRenderer : TableViewRenderer
    {
        protected override void OnElementChanged(ElementChangedEventArgs<TableView> e)
        {
            base.OnElementChanged(e);

            if (Control != null)
            {
                // Apply the fix for the TableViewRenderer on iOS
                Control.DelaysContentTouches = false;
            }
        }
    }

Don’t forget to register the custom renderer!

public static MauiApp CreateMauiApp()
 {
  var builder = MauiApp.CreateBuilder();
  builder
   .UseMauiApp<App>()
   .UseMauiCommunityToolkit()
   .ConfigureFonts(fonts =>
   {
    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
   })
            .ConfigureMauiHandlers((handlers) =>
            {
#if IOS
                handlers.AddHandler(typeof(TableView), typeof(Platforms.iOS.Renderers.MyTableViewRenderer));
#endif
            });

Conclusion
I’ve shown you how to avoid the annoying interaction delay when using a DrawingView is inside a scrollable layout, in .NET MAUI for iOS. Hope it’s helpful and feel free to share your thoughts about this post.

Here you can find a working sample with the implementation suggestion s described on this post.

How to use a DrawingView inside a scrollable layout, in .NET MAUI was originally published in Medialesson on Medium, where people are continuing the conversation by highlighting and responding to this story.

How to work with MongoDB in hybrid environments using On-Premises and Azure Cloud.

Introduction

When creating a system that involves accessing a database, it is very common to use a local database environment during development. In some cases, a local database engine might not have the same characteristics as the production one. One example is a On-Premises MongoDB versus an Azure Cosmos DB account.

One of the main differences we’ll find between these two environments (On-Premises and Cloud) is the fact that in Azure Cosmos DB we need to take the throughput into account when creating databases and collections. Throughput determines the amount of resources that an Azure Cosmos DB instance will have available to operate. To make things a bit more dramatic, managing the throughput correctly is imperative to avoid having to pay for unnecessary resources at the end of the month. In an On-Premises environment, this is usually not something we need to be concerned about.

In this story I’ll show you an approach to handle both environments (On-Premises and Cloud), taking into account that the throughput and configuration is needed for each one.

Getting ready

The complete source code of this solution (including a small usage sample), can be found here.
To run it you need:
- VS2017+
- MongoDB 3.2 (for On-Premises instalation click here)
- Azure Cosmos DB 3.2 (to create a new account click here)
Important nuget packages:
- Microsoft.Azure.DocumentDB.Core
- MongoDB.Driver

NOTE: If you’re creating a new Azure Cosmos DB account, be sure to select the correct API and Version

Implementation

The full source code includes all the basic implementation expected in a database access service (create, delete, update), so feel free to explore it. In this section I’ll focus only on the main parts related to the handling of the different database environments.

Environments configuration
Since we are dealing with different environments, each with its own particularities, we´ll need to have a way to switch between them. For that we use a configuration class.

The configuration class holds several properties, some specific to a particular environment, but here are three properties that are common to all environments:
- DatabaseLocation: Defined by the DbLocation enum.
- DatabaseName: Name of the database to create/connect.
- Connection string: Connection string to the database instance.

NOTE: The connection string for the Azure Cosmos DB service can be obtained after the account is created by going to the menu option “Connection Strings”. There you´ll find the connection string that you need to include in the configuration for the Cloud environment.

In the provided sample code we have a MongoDbFactory class that handles the database creation. This class receives the configuration as a constructor parameter and uses it to define which code to execute depending on the defined DatabaseLocation.

Continue to read to take a look at how we deal with the database creation in the different environments!

Database Creation
With the configuration in place, the second step is the database creation.
For DbLocation.Local environments, the creation is fairly straightforward. In fact, creating a database in an On-Premises pure MongoDB instance it’s as simple as calling the GetDatabase method found in MongoDB.Driver.MongoClient. Check out this post for a more detailed explanation on how to use MongoDB driver in On-Premises instances.

Creating a database in Azure Cosmos DB involves also defining the throughput value. Although this is not a mandatory step, we wanted to be sure of the throughput that was assigned to a new database.

There are 2 major steps in the above code, to create a database on Azure Cosmos DB:

• First step is to create a connection to the Azure Cosmos DB service, using the DocumentClient class provided in the Microsoft.Azure.DocumentDB.Core nuget package. This is done in the GetDocumentClient method.
• Second step is to create the database, using the DocumentClient.CreateDatabaseIfNotExistAsync method. The special part in this call is the RequestOptions class that allows you to define the throughput to assign to the database when creating it. More info on how to manually provision throughput in Azure Cosmos DB, can be found here.

Creating Collections
So far so good! We have a database created and now we’ll add some collections. In our case, we used shared throughput which means that we had to create sharded/partitioned collections.

In layman´s terms, creating a sharded collection means that you must explicitly define the partition key of the collection. You can do that by sending a command to the database. MongoDB commands and queries are all JSON documents, so we can use the driver’s BsonDocument class to construct the command (click here to get more info on this topic). The code to create a sharded collection looks like this:

The shardCollection is the fully qualified database and collection name followed by the hashed key.

The more generic way of using the MongoDb Driver to create a collection is by calling the CreateCollectionAsync method that takes the collection name. To be sure that we also support On-Premises pure MongoDB instances, we should ensure that it has a fallback method to the shard collection creation. The code would look something like this:

Throughput management
And finally we reach the throughput management. Our use case forced us to have a higher throughput at startup to be able to import large quantity of data. Once that data was imported, the throughput is scaled down to reduce unnecessary costs.

We calculate the final shared throughput based on the number of existing collections, so the first step is to query the database to get the count of existing collections. The code for that looks like this:

To actually change the throughput, we use the method ReplaceOfferAsync. This method comes from the DocumentClient class provided in the Microsoft.Azure.DocumentDB.Core nuget package. The code to make the throughput change looks like this:

Note that there´s a minimium limit for the defined throughput (in our case 400), so we must ensure that the value of the offer is above that limit. To make that calculation we assign an arbitrary value of 100 for each existing collection and we make sure that the final value is not bellow 400:

• Math.Max(400, (collectionCount * 100))

Summary

In the end we get an ‘abstraction’ layer that allows us to seamlessly change between different MongoDB database environments. The environment swap is achieved by using an environment specific configuration that will provide the necessary information to decide on how to interact with the database service.

This implementation targets MongoDB v3.2, but currently Azure Cosmos DB supports version v3.6, meaning that as a future implementation, one could expand this approach to also support v3.6 databases.

Working with MongoDB On-Premises and Cloud environments was originally published in Medialesson on Medium, where people are continuing the conversation by highlighting and responding to this story.