DEV Community: Laura Pučkoriūtė

Event-Driven Architecture: When and How?

Laura Pučkoriūtė — Tue, 27 Jan 2026 17:55:47 +0000

After spending the last three years building high-assurance event-driven systems in healthcare and recently diving deep into Domain-Driven Design (DDD), I want to bridge these two worlds by breaking down the core concepts of Event-Driven Architecture. If you are brand new to EDA, I invite you to use this blog post as a starting point. Let’s dive into the basics!

Event-Driven Architecture (EDA) is a paradigm that works with creating, detecting, and consuming events. In Microservice Architecture, services act either as producers of those events, consumers, or both. Business and domain needs dictate whether these architecture patterns should be selected.

There are a few reasons why you might choose an event-driven design for your system.

Asynchronous communication: You might be designing a system where you want to avoid long wait times for something to happen. Then you could allow one part of your system to proceed rather than waiting for a response.

For example, you are designing a library book reservation system with a high number of users. While it may seem unrealistic, let’s imagine hundreds of book reservations or reservation cancellations per second. You want to let the user know that the book has been reserved instead of making the user wait for a few seconds or longer until the reservation database is actually updated. If you choose Event-Driven Architecture (EDA), your service that interacts with the user in this scenario is not blocked and doesn’t need to wait for their book to be reserved. We trust that the architecture will handle the user’s request and eventually reserve their book.
Decoupled systems: If you are implementing EDA in a microservice architecture, you can clearly see how event producer and consumer services operate independently. The separate management of these services is crucial for their scalability and adaptability to changes in business requirements.
Business logic across multiple consumers: You might find that your business requirements ask you to ensure that when one type of event happens, multiple other services can pick the process up from there and decide independently how to respond to specific events.

Can EDA be used in monolithic applications?

Yes, it can. It means the same application/service will be responsible for producing and consuming the events. It depends on the business requirements. One thing that monolithic architecture does not offer is physical decoupling of services. In microservice architecture, the event producer and consumer services are truly independent of each other. If something fails in the consumer service, for example, the producer and event backbone systems stay healthy. Once the consumer service is repaired and running smoothly, it can pick up the events from the queue or an event stream (event backbone), ensuring data reliability.

What are producers, consumers, and the event backbone?

It’s very simple. A producer is a service that creates the event. A consumer is a service that receives the event and reacts to it. And the event backbone is a service that sits in between the two and stores those events, almost like a mailbox.

Let’s say I have to design a system that deals with a high number of book reservations. After conversations with the business team in order to understand the domain, I have identified one of the events - the user reserved a book. That means there should be a producer service that creates the event BookReserved. This event should hold information about which user reserved the book and what book that is. The producer service pushes the event to the event backbone system that holds many BookReserved events.

I also have a third service - consumer. My consumer service is set up in a way that is constantly listening to the event backbone system to see if there are any new events. Once it picks up the BookReserved event, the consumer reads information about the book and the user. Then the consumer calls certain functions that mark the reservation in the database, change the status of that specific book instance, and similar.

As you can see from the diagram above, I selected my producer and consumer services to be implemented in .NET. Of course, it could be any other framework that fits your business needs and the team’s skillset.

How does the event backbone work?

The event backbone is the core of EDA. It is a crucial infrastructure component that can be implemented as an event bus, event broker, event router, or event hub (you may have heard some of these names).

The event backbone is the medium through which events produced by one component (the producer) are communicated to other components (the consumers). It ensures that when an event occurs, relevant consumers are notified and can act upon it independently.

Functionality:

Producers inform the event backbone about events of interest.
The event backbone routes these events to the appropriate consumers based on their subscriptions.

Technologies:

Many technologies implement the event backbone mechanism. The choice of which one to pick depends on how you want the events to be processed. Should we treat the events as a temporary message to be delivered or a permanent record to be stored?

Thinking of the messages in terms of their life span really helped me understand the difference between various technology options.

Event data purpose	Technology category	Event Backbone Tools
Temporary Message	Message Brokers	RabbitMQ, ActiveMQ, AWS SQS / Azure Service Bus, NATS, IBM MQ
Semi-Permanent	Event Streaming	Apache Kafka, Redpanda, Apache Pulsar, Azure Event Hubs / AWS Kinesis
Permanent record	Event Sourcing	EventStoreDB, Marten, Axon Server, Eventuate

The specific code you write for your producers and consumers to integrate with the event backbone is traditionally tied to the backbone technology you choose. Using a tool's native SDK means your code must follow a specific protocol, whether it's RabbitMQ's exchanges or Kafka's partitions.

There exist backbone-agnostic libraries, like Wolverine in .NET. They act as an abstraction layer between the code and infrastructure. You would set the right configuration, and then write generic handlers while letting the Wolverine framework manage the underlying connection to the event backbone.

Summary

Event-Driven Architecture allows microservices to operate independently, reducing latency and preventing system-wide bottlenecks. However, the most critical takeaway isn't the tech stack. It's the alignment with your domain. Whether you choose a Message Broker for instant tasks or Event Streaming for a historical record, the decision must start with your business requirements. By understanding how your data needs to live and move, you can build a system that isn't just "event-driven," but purpose-driven.

Certified! Azure AI-102: AI Engineer Associate

Laura Pučkoriūtė — Thu, 12 Jun 2025 17:00:58 +0000

In June 2025, I took and passed the Azure AI-102 certification exam. I would like to share my experience and what might be useful for someone else on this journey.

As AI is inevitably becoming the new game of the industry, naturally, many will want to learn more about it. My key driver was to learn what’s possible. Before my studies started, I had seen multiple PoCs, heard of ideas, and seen extraordinary AI applications changing people’s lives in many areas. But this certification focused on the Azure services was supposed to empower me to participate in conversations and ideation processes for AI-powered applications, to help me think creatively, consider ethical accountabilities, and business needs. And so it enabled me to do this.

My study journey

To set the context, the time frame of my preparation was probably not ideal due to the recent changes to the content on the 30th of April. On the 1st of May, I first looked at the content and started my study path, and a month later, I took the exam. I followed the official learning path for the certification, and I would conclude that the path is designed carefully. It’s straightforward and should be your main source for study. It includes quizzes and hands-on labs, which were very valuable.

Although the MS Learn path for Azure AI-102 certification was long and had good coverage, I am glad I also spent time reading the official documentation found on the MS Learn website.

Using AI to learn about AI

Because I felt that I couldn’t remember everything and my deadline for the exam was a bit tight, in the last week or so, I decided to ask Google Gemini to generate certification-style questions and make a quiz for me based on the content in the documentation that I was revising. I did this not only because I wanted focused revision on specific topics, but also because there are so few resources out there for mock exams of this specific certification. These Gemini-generated quizzes are what got me into an assessment mode and even helped me get into the habit of using intuition when I couldn’t rely on the confidence of my knowledge.

Whatever your reason might be, it could be a useful approach. But never abandon the act of actually reading the documentation, and ensure that your AI chat is not hallucinating by grounding it on the exact content you are interested in.

Create a 10-question quiz based only on the content in this documentation: https://docs.azure.cn/en-us/ai-services/language-service/question-answering/overview

Follow the Azure certification exam question style:
You have a question answering project.
A customer asks a question that is not part of the project.
You review the active learning suggestions and do not see any suggestions.
You need to ensure that customer questions are included in the active learning suggestions. The solution must minimize administrative effort.
What should you do?

Practice material online

📚 If you have access to O’Reilly resources, this resource provides revision questions. Although the questions are ridiculously easy compared to the actual exam.

📚 Whizlabs also has some practice tests available that are more in the format of the exam. I am not sure how up-to-date they are since the last change to the exam, but at the moment, you can Try Free Test of 15 questions.

📚 Udemy has practice tests with questions similar to those in the actual exam.

You don’t need them all. For me, doing the free test on Wizlabs was enough to get the gist of what to expect. But I imagine if I had purchased more of those tests, I would have felt maybe a bit more confident.

And most importantly, take the practice assessment provided on the official certification page. It will generate a report that you can use to identify your weaker sections and will even create a revision plan for you.

My time

In total, I spent 8 full work days - about 7 hours each, going through the learning path. And then about 3 hours for 8 more days revising, looking into more details in the documentation, repeating the lab exercises, and quizzing myself.

How was the exam?

I took my exam online. I had never done this before, but the overall setup and check-in process went smoother than I expected. As long as you have completed the system check on your machine before the exam, you can be calm and enjoy the comfort of your home during the assessment.

The questions in the exam included:

single-choice and multiple-choice questions
code/json completion exercises with dropdown options
building lists in the right order
one Hot Area question to determine what I would click to achieve an objective
Mark Review questions
Case Studies questions

There was no lab exercise during my exam.

At the end, there were six questions dedicated to one case study. You will see it clearly in the progress bar when you get to them. Don’t forget to use the buttons in the left pane to expand and read the case study information!

MS Learn

You can also access Microsoft Learn documentation during the assessment, but be extremely mindful of your time. I used it for a couple of questions, and even then only quickly scanned through the pages. There is a limit of maybe 5 tabs that you can open. See how you can access the documentation.

Exam time

From the moment you start the assessment, you will see a timer counting down the minutes you have left to finish the exam. You have 100 minutes + 20 minutes more, which includes a break and any adjustments in case you need them. The time you see counts for both parts of the assessment - the first ~50 questions, as well as the last 6 questions dedicated to the case study. It also includes the review time.

Difficulty

The difficulty of the questions was what I expected - difficult. I had to use intuition a lot and have internal conversations about why I chose this answer over the other. It’s the little details in the question that matter. I didn’t know everything and didn’t have time to look up the documentation, but as long as I had an overall knowledge of the services, experience with the labs, and common sense, I was able to answer with some confidence.

If you want to learn from my mistakes:

Keep up the pace during your assessment - time flies by when you’re having fun ;)
Expand for more information in the last case study questions - I forgot it was a thing pressured under the time limit
If you want to keep tissues or chewing gum on your desk, take them out of the packaging

Exam day

The weekend before the exam, I went dancing (one of my passions). Some friends told me to study instead, but I know what works for me. Study and practice early, not the night before. My rule of thumb - from 3 pm on the day before the exam, I am not allowed to study, take practice tests, or revise. It’s rest time.

You might not know everything that’s in the exam. You might not feel confident. But you stuck to your plan, and que sera, sera. You are capable, you’ve done the work, find your peace.

I took my exam online, and when I saw the page with my results indicating that I successfully received my certification, I sighed with relief and thought of my exam proctor - “Is he proud of me?”

This is what I wish for you - may your proctor be proud of you. Good luck with your studies. You’ve got this!

JavaScript Bridge in X-Platform MAUI app

Laura Pučkoriūtė — Sun, 26 Jan 2025 20:02:34 +0000

JavaScript Bridge is a way to allow communication between the native MAUI app and a web application rendered in a WebView. It enables a seamless two-way interaction, allowing native functionality to interact with web content and vice versa.

With a JavaScript bridge, you can:

Enable two-way communication between the native and the web applications
Access native device functionality from the web app
Reuse the existing web application in your MAUI project and avoid code duplication

MAUI to Web communication

MAUI project code

You’ve got your Web application rendered in a WebView in the MAUI project. Now if you want to call a JavaScript function defined on the Web Application, you can simply execute code like this from your WebView page:

// Call JavaScript from the WebView
await myWebView.EvaluateJavaScriptAsync("window.nativeAppCallbacks.updateNativeSettings(data)");

The script parameter can be anything you want. A simple alert function or something specifically defined for the MAUI to Web communication in your application.

Web project code

window.nativeAppCallbacks = {
        updateNativeSettings(settings) {
        // some code to update the state
    },
};

Web to MAUI communication

MAUI project code

If your MAUI application is cross-platform, for example, it can be run on both Android and iOS operating systems, you’ll want to create two platform-specific services defining the functionality that can be executed from the web app.

Android

using Android.Webkit;
using Java.Interop;

namespace MyApp.Platforms.Android;

public class JavascriptBridge(LoggedInWebView loggedInWebView) : Java.Lang.Object
{
    [JavascriptInterface]
    [Export("fetchNativeAppSettings")]
    public void FetchNativeAppSettings()
    {
        MainThread.InvokeOnMainThreadAsync(() => MyWebView.FetchNativeAppSettings());
    }
    ...
}

The [JavascriptInterface] attribute is used to mark a class or interface in your Android MAUI project so that it can be accessed by JavaScript running in a WebView. It tells the Android runtime that this class or object will serve as a bridge between JavaScript and native code. Without this attribute, the methods in the class cannot be invoked from JavaScript.

The [Export("methodName")] attribute is applied to methods within a class to specify the exact method name the web project will use to call this function.

Then, you can create a HandlerService class which will be used to register your new JavaScript bridge on a WebView.

using Microsoft.Maui.Handlers;

namespace MyApp.Platforms;

public class MyWebViewHandlerService : IMyWebViewHandlerService
{
    public void SetHandler(IWebViewHandler handler, IWebView webView)
    {
        handler.PlatformView.Settings.JavaScriptEnabled = true; 
        var javascriptBridge = new JavascriptBridge((MyWebView) webView);
        handler.PlatformView.AddJavascriptInterface(javascriptBridge, "nativeApp");
    }
}

Please note, that although the namespace does not specify the platform used, this code should be in the Android folder. The namespace is inaccurate here so that the code can be accessible from shared non-platform-specific folders. For example, from the page class itself.

Wherever in your MAUI app code you deal with the IWebViewHandler , you should enable JavaScript execution for your WebView, which for security reasons by default is disabled. Most importantly, add your JavaScript bridge to the Android-specific WebView control handler.PlatformView .

nativeApp is a JavaScript object which will contain all the JS functions defined in the bridge. So the web app can call nativeApp.fetchNativeAppSettings() .

iOS

Implementing the JavaScript on the iOS side is slightly different, but not too complicated.

Again, you want to create a JavaScript bridge class, just like for Android.

using Foundation;
using Microsoft.Extensions.Logging;
using WebKit;

namespace MyApp.Platforms.iOS;

public class JavascriptBridge : NSObject, IWKScriptMessageHandler
{ 
    private readonly WeakReference<MyWebView> _myWebViewRenderer;

    internal JavascriptBridge(MyWebView myWebView)
    {
        _myWebViewRenderer = new WeakReference<MyWebView>(myWebView);
    }

    public void DidReceiveScriptMessage(
            WKUserContentController userContentController,
            WKScriptMessage message)
    {
        if (!_myWebViewRenderer.TryGetTarget(out var renderer))
        {
            return;
        }

        switch (message.Name)
        {
            case "fetchNativeAppSettings":
                renderer.FetchNativeAppSettings();
                break;
            default:
                return;
        }
    }
}

iOS JS Bridge has to extend IWKScriptMessageHandler and implement its member DidReceiveScriptMessage. Whenever the JavaScript function is called, DidReceiveScriptMessage will be executed. This is where we check which JavaScript function was called and act accordingly. We can get the JavaScript function name with message.Name and the parameters by looking at the message.Body.

Great, now let’s create a HandlerService in the iOS folder which will be used to expose all these functions from the bridge to the WebView. This has to be done by building a string with actual JavaScript code.

using Foundation;
using Microsoft.Maui.Handlers;
using WebKit;

namespace MyApp.Platforms;

public class MyWebViewHandlerService : IMyWebViewHandlerService
{
        private const string JavascriptCode = 
          """
                window.nativeApp = {};
                window.nativeApp.fetchNativeAppSettings = function(request) {
                    window.webkit.messageHandlers.fetchNativeAppSettings.postMessage(request);
                }
          """;

    public void SetHandler(IWebViewHandler handler, IWebView webView)
    {
        var javascriptBridge = new MyJavascriptBridge((MyWebView) webView);
        var script = new WKUserScript(new NSString(JavaScriptCode), WKUserScriptInjectionTime.AtDocumentEnd, false);
        handler.PlatformView.Configuration.UserContentController.AddUserScript(script);
        handler.PlatformView.Configuration.UserContentController.AddScriptMessageHandler(javascriptBridge, "fetchNativeAppSettings");
    }
}

This code:

creates JavaScript code string which defines what happens when the Web app makes calls window.nativeApp.fetchNativeAppSettings() function. When that happens, it will post a message containing the name of the function and parameters to a fetchNativeAppSettings handler
AddUserScript adds this JavaScript code to the iOS-specific platform controller
AddScriptMessageHandler installs a message handler that we call from the script (JavascriptCode ) that we just added to the controller

Web project code

What your web code looks like will depend on your Web App Framework. Most likely, you’ll have a JavaScript code that is something like this. It’s that simple.

if (window.nativeApp && app.fetchNativeAppSettings) {
  const appVersion = app.fetchNativeAppSettings();
}

Benefit during migration

JavaScript bridge is an excellent and pretty straightforward way to enable two-way communication for your native app rendering a web one.

On my project, we performed a Xamarin to MAUI cross-platform native app migration. This is when we implemented a MAUI JavaScript bridge for interaction with our Vue app. We found that we didn’t need to change a single line of code in the web project.

Currently, we are looking to migrate from Vue to the Blazor Web application. Having done some investigation and written a bit of code, it’s clear to see that although we’ll have a completely new and different .NET web application, there will be no changes that we’ll have to make to the native MAUI app codebase.

Readings ✨

Invoking JavaScript in MAUI

Understanding handlers in MAUI

Please look at the Apple Documentation for more details on JavaScript message handlers

Why Your .NET Application Works in an IDE but Fails in CI/CD or Terminal: Understanding Asynchronous Execution

Laura Pučkoriūtė — Fri, 06 Dec 2024 17:16:33 +0000

Yup, I missed an await .

Nothing new. No one else to blame.

But why did it take so long to find it? Because the app worked locally but failed on the pipeline, I thought it was a pipeline problem! Is the Azure pipeline set up in some way that doesn’t wait for my dotnet run command to finish? Does an error occur that is not properly logged and therefore not visible on the pipeline run? Do I need to use a different Azure DotNetCoreCLI task or instead start the program with a shell script? Am I losing my mind?

Asynchronous programming can be tricky, especially when tasks are not awaited properly. This often leads to unexpected behavior, especially when running applications in different environments (like Rider or other IDEs vs. the terminal or CI/CD pipelines).

My case

static void Main(string[] args)
{
    SomeProcess(); // Missing await
}

static async Task SomeProcess() {
    await SomeOtherProcess();
}

My Main function called a process that had a few asynchronous tasks. On the pipeline, observing the logs, I saw that the pipeline task running the program would be completed at random times, rarely letting the .NET program complete a full run.

That is because the call in the Main function to a process initiating asynchronous tasks never waited for that process to complete, and the Main function run finished whenever it pleased.

But why did the .NET program always run fully in the Rider IDE?

Seems like Rider might have a specific run environment. Rider might implicitly handle unawaited tasks, potentially waiting for asynchronous tasks to complete before terminating the run process, allowing the app to seem to run fully. An IDE might introduce additional debugging or process-wait mechanisms that make the application appear to be more forgiving in certain cases.

When running in the terminal or CI/CD pipelines, there is no "help" from Rider or other IDEs. The application exits immediately after the Main method finishes, even if tasks are still running in the background. Without await, these background tasks won’t finish before the application ends, leading to errors or incomplete operations.

How I fixed it

First, it was important to start my application by running the dotnet run command from the terminal, and not an IDE. This way it was clear that the problem was in the application code, not in my pipeline setup.

Then, I had to dig a bit through the code to find where exactly I was not handling the asynchronous processes properly. Once I found it, I added the missing await statement. And it worked like magic.

static async Task Main(string[] args)
{
    await SomeProcess();
}

static async Task SomeProcess() {
    await SomeOtherProcess();
}

Lessons learned

Always await asynchronous operations.
Test in multiple environments: test the run of your application in a terminal or similar environment to where it is failing.
Do not rely just on the IDE run processes to verify the functionality of your program.

Receiving Push Notifications from Firebase in Android MAUI

Laura Pučkoriūtė — Fri, 27 Sep 2024 15:12:37 +0000

Background

My team has recently implemented push notifications for our Android MAUI (.NET Multi-platform Application UI) app. This implementation was part of our ongoing migration from Xamarin to MAUI in a cross-platform mobile healthcare application. The app is designed to help users manage their health by providing timely information, reminders, and updates.

One of the key features of this healthcare app is its ability to receive push notifications that include links directing users to specific pages within the app. This functionality ensures that users can quickly and easily access relevant information or take necessary actions directly from the notifications.

To power this feature, we are utilizing Firebase as the backend service for sending out messages. Firebase Cloud Messaging service provides a reliable and scalable solution for managing and delivering push notifications.

To provide some context, this diagram represents the part of our system responsible for sending push notifications. As you can see, we utilize Azure Notification Hub to handle this functionality.

Although the MainActivity class code given in this post is Android platform-specific, the Firebase Cloud Messaging Service and the cross-platform services executed from the MainActivity can work nicely with an iOS app implementation.

To receive push notifications on your app you need to:

ask the user’s permission for the app to display notifications
register the user’s device with the Firebase project
handle the receiving of the notification

In this post, let’s discuss the last part - receiving the notification. Our app loads a single-page application that routes to different pages, so let’s focus on a notification that contains a link to one of the app’s pages. These examples could also be applied to any other data type that each app would need the data object of the Firebase message to contain.

Let’s say we want to send a notification with these JSON values to the device where the app is deployed.

{
    "notification": {
        "title" : "You received a message",
        "body" : "Click to view your in-app messages."
    },
    "data": {
        "url" : "https://my-app/messages"
    }
}

Ultimately, we want the act of clicking the notification in the notifications tray to open the app, and if the Firebase message contains some extra data (like a URL), to pass along that data through an Intent object. Then the Android app should pick the data up and do something with it.

What is an Intent?

In Android, an Intent is a messaging object used to request an action from another app component and share some information.

For example, the Intent object is created by the Firebase Cloud Messaging service when a user clicks on a notification. The Intent contains the data from the notification and is passed to the OnCreate method of the app activity that is launched by the notification. Our code implementation decides what we do with that Intent object. We might want to ignore it or, if the data in the Intent makes sense, we can execute some action. In our case, if the Intent object contains a URL field, we will try to use that URL to direct the user to the correct page in our application.

Implementation

We've learned that an Android app can operate in three different states: closed, in the background, or in the foreground. In each scenario, the push notification intent might need to be handled differently, especially if it contains a URL field for opening a specific page within the app.

Closed App

We found that receiving and handling a notification from Firebase was very easy when the app is closed. The Firebase SDK would handle the receipt of the message, create a notification, and display it for the user. Once the user clicks the notification, the default activity will be started. In your activity class, the OnCreate method will be executed. At this stage, we can get the URL from the Intent object that was created by FCM, and then we use it to redirect the user to a specific screen in the app.

The MainActivity class in Android is the entry point for your application. It is a subclass of the Activity class, which is a crucial component of an Android application. An activity represents a single screen with a user interface.

[Activity(Theme = "@style/Maui.SplashTheme", 
                    MainLauncher = true,
                LaunchMode = LaunchMode.SingleTop)]
public class MainActivity : MauiAppCompatActivity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        HandleIntent(Intent);
    }

    private static void HandleIntent(Intent intent)
    {
        if (intent == null)
        {
            return;
        }

        var url = intent.Extras?.GetString("url");
        if (string.IsNullOrWhiteSpace(url))
        {
            return;
        }

        if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out var uri))
        {
            Microsoft.Maui.Controls.Application.Current?.SendOnAppLinkRequestReceived(uri);
        }
    }
}

In this example of the MainActivity class, we create a Uri object and pass it to the SendOnAppLinkRequestReceived method defined in App.xaml.cs file. This is great because the App class contains cross-platform code. So if you are also implementing an iOS notification URL handling, your iOS-specific code can call the same cross-platform method in this App class and carry on with the same redirection behavior.

public partial class App
{
    private readonly IAppNavigationService _appNavigationService;

    public App(IAppNavigationService appNavigationService)
    {
        InitializeComponent();
        _appNavigationService = appNavigationService;
    }

    protected override void OnAppLinkRequestReceived(Uri uri)
    {
        base.OnAppLinkRequestReceived(uri);

        var currentPage = _appNavigationService.GetCurrentPage();
        currentPage.HandleDeepLinkRequest(uri);
    }
}

Each page might do something different with this URI (sometimes redirect, sometimes ignore). That’s why we chose to implement and call a method for handling the URI in each page separately.

App Running in the Background

When the app is running in the background (minimized), Firebase again handles the notification creation and display. When the user clicks on this notification, the app will be foregrounded, but the OnCreate method will not be called as the activity is already running. Instead, we need to override another method - OnNewIntent(). This will be automatically called when the user clicks on the notification. In this method, we can get the URL from the intent parameter and redirect.

[Activity(Theme = "@style/Maui.SplashTheme", 
                    MainLauncher = true,
                LaunchMode = LaunchMode.SingleTop)]
public class MainActivity : MauiAppCompatActivity
{
    // ...

    protected override void OnNewIntent(Intent intent)
    {
        base.OnNewIntent(intent);

        HandleIntent(intent);
    }

    private static void HandleIntent(Intent intent)
    {
        if (intent == null)
        {
            return;
        }

        var url = intent.Extras?.GetString("url");
        if (string.IsNullOrWhiteSpace(url))
        {
            return;
        }

        if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out var uri))
        {
            Microsoft.Maui.Controls.Application.Current?.SendOnAppLinkRequestReceived(uri);
        }
    }
}

Note on the Launch mode

In .NET MAUI, the LaunchMode = LaunchMode.SingleTop activity configuration is used to control the behavior of your app's activity in response to push notifications or other intents. This launch mode ensures that if an instance of the activity already exists at the top of the activity stack, it will be reused instead of creating a new instance. This is exactly the scenario we want to have when the app is running in the background.

App Running in the Foreground

When the app is open and a Firebase message is sent, the Firebase SDK doesn’t create and display the notification for us. We have to do this ourselves. For this reason, we implemented a messaging service extending the FirebaseMessagingService class. This is where the OnMessageReceived method is automatically executed once the message is sent. By overriding this method, we were able to take the data from the remote message, build a notification ourselves, including the intent with the URL, and display it for the user in the device’s notification tray.

using _Microsoft.Android.Resource.Designer;
using Android.App;
using Android.Content;
using Android.OS;
using AndroidX.Core.App;
using AndroidX.Core.Content;
using Firebase.Messaging;

namespace MyApp.Platforms.Notifications;

[Service(Exported = false)]
[IntentFilter(["com.google.firebase.MESSAGING_EVENT"])]
public class NotificationMessagingService : FirebaseMessagingService
{
    private const string NotificationUrlDataKey = "url";
    private const string NotificationChannelId = "someChannelId";

    public override void OnMessageReceived(RemoteMessage message)
    {
        var notification = message.GetNotification();
        var notificationId = Guid.NewGuid().GetHashCode();
        var pendingIntent = BuildIntent(notificationId, message.Data);

        var builtNotification = BuildNotification(pendingIntent, notification);
        CreateNotificationChannel();
        SendNotification(notificationId, builtNotification);
    }

    private PendingIntent BuildIntent(int notificationId, IDictionary<string, string> data)
    {
        using var intent = new Intent(this, typeof(MainActivity));
        intent.AddFlags(ActivityFlags.SingleTop);

        if (data.TryGetValue(NotificationUrlDataKey, out var url) && !string.IsNullOrWhiteSpace(url))
        {
            intent.PutExtra(NotificationUrlDataKey, url);
        }

        return PendingIntent.GetActivity(
            this, 
            notificationId, 
            intent, 
            PendingIntentFlags.OneShot | PendingIntentFlags.Immutable);
    }

    private Notification BuildNotification(PendingIntent intent, RemoteMessage.Notification notification)
    {
        using var notificationBuilder = new NotificationCompat.Builder(this, NotificationChannelId);
        notificationBuilder
            .SetContentTitle(notification.Title)
            .SetContentText(notification.Body)
            .SetContentIntent(intent)
            .SetAutoCancel(true);

        return notificationBuilder.Build();
    }

    private void CreateNotificationChannel()
    {
            using var channel = new NotificationChannel(
            NotificationChannelId,
            "MyApp Notifications",
            NotificationImportance.Default);
        var notificationManager = GetSystemService(NotificationService) as NotificationManager;
        notificationManager?.CreateNotificationChannel(channel);
    }

    private void SendNotification(int notificationId, Notification notification)
    {
        var notificationManager = NotificationManagerCompat.From(this);
        notificationManager.Notify(notificationId, notification);
    }
}

This way, whenever a remote message is received from Firebase, the notification will be created and immediately displayed for the user. Once it’s clicked, OnNewIntent method in the activity class will be executed, and the URL is going to be used for redirection.

Some readings ✨

Android Activity
Launch Modes of Android Activity
Receive Messages in an Android App | Firebase Cloud Messaging
FirebaseMessagingService class