Our phones and computers are like magic doors to the world, thanks to the apps
we use every day. These apps show us stuff using a mix of words, pictures, and
special links that let us explore more. 🌐 Links, especially, make it easy for
us to dive deep into things. In this guide, we'll learn how to add these
special links to your .NET MAUI apps, making it more fun for people to check
out what you have to share. Join us on this enlightening journey as we unravel
the secrets of Transforming Labels into Hyperlinks with .NET MAUI.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Implementation
In this step, we'll include two labels within the horizontal layout to position them closely to each other.
The first text will serve as regular text, representing the standard label.
The second text will function as a hyperlink, characterized by blue text color and underlined as text decoration.
The following code snippet will help in grasping the concept more clearly.
You can download the code from
GitHub. If you have any
doubts, feel free to post a comment. If you liked this article, and it is
useful to you, do like, share the article & star the repository on
GitHub.
Welcome to our newest blog post, where we explore the vibrant realm of MVVM
(Model-View-ViewModel) architecture using the cutting-edge MVVM Toolkit in
.NET MAUI. In this comprehensive guide, we will unravel the intricacies of
MVVM and demonstrate how the MVVM Toolkit in .NET MAUI empowers developers to
create robust, responsive, and easily maintainable cross-platform mobile
applications. Join us on this enlightening journey as we unravel the secrets
of mastering MVVM in the context of .NET MAUI.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Install Plugin:
In this steps, we will see the steps to install "MVVM Toolkit" in .NET MAUI
project:
Access NuGet Package Manager: In Visual Studio, right-click on your
.NET MAUI project in the Solution Explorer. From the context menu, select
"Manage NuGet Packages."
Search for "CommunityToolkit.Mvvm": In the NuGet Package Manager,
click on the "Browse" tab. In the search bar, type "CommunityToolkit.Mvvm"
and hit Enter. The package should appear in the search results.
Select and Install the Package: Once you find "CommunityToolkit.Mvvm"
in the search results, click on it to select it. Ensure you choose the
appropriate version compatible with your .NET MAUI project. Click on the
"Install" button to begin the installation process.
Accept License Agreement: During the installation, you may be
prompted to accept the license agreement. Review the terms and conditions
and click on the "Accept" button to proceed.
Wait for Installation to Complete: Visual Studio will download and
install the package along with its dependencies. This process may take a few
moments, depending on your internet connection speed.
Verify Installation: After the installation is complete, verify that
there are no error messages in the Output window. This indicates a
successful installation of the package.
Implementation
View Model
In this step, we create a ViewModel that inherits from the ObservableObject
class. This inheritance is pivotal because ObservableObject implements the
INotifyPropertyChanged interface. By doing so, we gain the ability to
trigger the PropertyChanged event, a vital mechanism enabling the
notification of property value changes to subscribers, primarily the UI.
This synchronization is fundamental for effective data binding, ensuring
seamless coordination between the user interface and the underlying
ViewModel.
For example:
public partial class ItemEntryPageModel : ObservableObject
{
[ObservableProperty]
private int _id;
[ObservableProperty]
private string _name;
[ObservableProperty]
private string _description;
[ICommand]
public async void Save()
{
await Application.Current.MainPage.DisplayAlert("MAUI MVVM Sample", "Item Saved Successfully", "OK");
}
}
When we use the [ObservableProperty] attribute, properties can send
automatic alerts when they change. This is important for connecting data and
updating the user interface (UI) when properties change. When you apply the
[ObservableProperty] attribute to a property, it does a lot of necessary
coding work behind the scenes. It sets up the code needed to tell other
parts of the program when a property changes. This attribute saves time
because you don't have to write all this code manually. For Example:
"_description" & "_name" produces "Description" & "Name"
respectively.
The [ICommand] implementation is a way to connect methods or actions
in the app with what the user sees on the screen. For instance, it can
create a command called SaveCommand that's linked to the Save method. This
linking is crucial for making sure that when a user does something, like
clicking a button, the right action happens in the app.
View
Finally, we will design the View, where we create the user interface using
XAML. Here, we connect the UI elements to the ViewModel properties using
data binding expressions.
This connection enables the View to show and modify task data in real-time,
ensuring a dynamic and responsive user experience.
You can download the code from
GitHub. If you
have any doubts, feel free to post a comment. If you liked this article, and
it is useful to you, do like, share the article & star the repository on
GitHub.
Welcome to our newest blog post, where we explore the vibrant realm of app
development with .NET MAUI! In this detailed guide, we dive into the
intricacies of the "DataGrid Control for .NET MAUI," an outstanding free
plugin crafted to simplify your data management process. Uncover how this
plugin enables developers to effortlessly sort, filter, and present data,
elevating user experiences across cross-platform applications.
Telerik, SyncFusion, and DevExpress offer paid licenses, often accompanied by
trial versions or community licenses under specific terms. However, DevExpress
stands out by providing a set of controls that you can use absolutely free!.
As the demand for seamless data visualization and interaction grows, this free
plugin emerges as a game-changer for .NET MAUI enthusiasts.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Install Plugin:
In this steps, we will see the steps to install "DevExpress Grid" in Visual
Studio 2022:
Access NuGet Package Manager: In Visual Studio, right-click on your
.NET MAUI project in the Solution Explorer. From the context menu, select
"Manage NuGet Packages."
Search for "DevExpress.XamarinForms.DataGrid": In the NuGet Package Manager, click
on the "Browse" tab. In the search bar, type "DevExpress.XamarinForms.DataGrid" and hit
Enter. The package should appear in the search results.
Select and Install the Package: Once you find "DevExpress.XamarinForms.DataGrid"
in the search results, click on it to select it. Ensure you choose the
appropriate version compatible with your .NET MAUI project. Click on the
"Install" button to begin the installation process.
Accept License Agreement: During the installation, you may be
prompted to accept the license agreement. Review the terms and conditions
and click on the "Accept" button to proceed.
Wait for Installation to Complete: Visual Studio will download and
install the package along with its dependencies. This process may take a few
moments, depending on your internet connection speed.
Verify Installation: After the installation is complete, verify that
there are no error messages in the Output window. This indicates a
successful installation of the package.
Implementation
Open MauiProgram.cs file, and add ".UseDevExpress()" in builder like below
The above code snippet represents a DataGrid component in .NET MAUI
application. Let's break down the properties and their meanings in the context
of this DataGrid:
ItemsSource="{Binding Items}": Binds the DataGrid to a collection of
items represented by the "Items" property in the ViewModel. Each item in
this collection corresponds to a row in the DataGrid.
dxg:DataGridView.Columns: Specifies the columns to be displayed in the
DataGrid.
dxg:TemplateColumn: We can use the custom templated column
dxg:TextColumn: Used to display the values in the column
dxg:DateColumn: Used to display the date values with datepicker selection in the column
dxg:ComoboxColumn: Used to display the values with dropdown selection in the column
dxg:CheckBoxColumn : Used to display the boolen selection with checkbox in the column
The below code snippet configures a DataGrid component with specific properties and
templates, allowing users to view and interact with data in a visually
appealing manner.
The Code Behind or MVVM view model properties are similar to listview control
and no specific code required
using System.Collections.ObjectModel;
using System.Net.Http;
using System.Net.Http.Json;
namespace MauiDevExpress
{
public partial class MainPage : ContentPage
{
public MainPage()
{
BindingContext = this;
InitializeComponent();
}
protected override async void OnAppearing()
{
base.OnAppearing();
await Task.Delay(2000);
LoadData();
}
private void LoadData()
{
var monkeys = new List<Monkey>
{
new Monkey
{
Name = "Chimpanzee",
Location = "Africa",
Details = "Chimpanzees are intelligent primates known for their problem-solving abilities.",
Image = "chimpanzee.jpg",
Population = 150000,
Latitude = -1.2921f,
Longitude = 36.8219f,
BirthDate = new DateTime(2000, 1, 15),
AccessLevel = AccessLevel.Admin
},
new Monkey
{
Name = "Orangutan",
Location = "Borneo",
Details = "Orangutans are great apes native to the rainforests of Borneo and Sumatra.",
Image = "orangutan.jpg",
Population = 70000,
Latitude = 1.3521f,
Longitude = 110.4647f,
BirthDate = new DateTime(2005, 3, 20),
AccessLevel = AccessLevel.User
},
new Monkey
{
Name = "Gorilla",
Location = "Africa",
Details = "Gorillas are the largest primates and share about 98.3% of their DNA with humans.",
Image = "gorilla.jpg",
Population = 100000,
Latitude = -0.2280f,
Longitude = 15.8277f,
BirthDate = new DateTime(1998, 7, 10),
AccessLevel = AccessLevel.Admin
},
// Add more monkey instances with BirthDate and AccessLevel properties
new Monkey
{
Name = "Howler Monkey",
Location = "South America",
Details = "Howler monkeys are known for their loud vocalizations that can be heard up to 3 miles away.",
Image = "howler_monkey.jpg",
Population = 50000,
Latitude = -14.2350f,
Longitude = -51.9253f,
BirthDate = new DateTime(2002, 5, 3),
AccessLevel = AccessLevel.User
},
new Monkey
{
Name = "Capuchin Monkey",
Location = "Central and South America",
Details = "Capuchin monkeys are highly intelligent and are often used in scientific research.",
Image = "capuchin_monkey.jpg",
Population = 30000,
Latitude = 4.7100f,
Longitude = -74.0721f,
BirthDate = new DateTime(2007, 9, 18),
AccessLevel = AccessLevel.Admin
},
new Monkey
{
Name = "Spider Monkey",
Location = "Central and South America",
Details = "Spider monkeys are known for their long limbs and prehensile tail, which they use to swing through trees.",
Image = "spider_monkey.jpg",
Population = 25000,
Latitude = 14.634915f,
Longitude = -90.506882f,
BirthDate = new DateTime(1999, 11, 7),
AccessLevel = AccessLevel.User
},
new Monkey
{
Name = "Mandrill",
Location = "Africa",
Details = "Mandrills are colorful monkeys found in the rainforests of Central Africa.",
Image = "mandrill.jpg",
Population = 10000,
Latitude = 0.2280f,
Longitude = 14.8277f,
BirthDate = new DateTime(2004, 2, 14),
AccessLevel = AccessLevel.Admin
},
new Monkey
{
Name = "Tarsier",
Location = "Southeast Asia",
Details = "Tarsiers are small primates known for their big eyes and unique hunting skills.",
Image = "tarsier.jpg",
Population = 5000,
Latitude = 9.3275f,
Longitude = 123.3076f,
BirthDate = new DateTime(2001, 8, 22),
AccessLevel = AccessLevel.User
},
new Monkey
{
Name = "Golden Lion Tamarin",
Location = "Brazil",
Details = "Golden lion tamarins are endangered primates with striking orange fur and manes.",
Image = "golden_lion_tamarin.jpg",
Population = 1500,
Latitude = -22.9068f,
Longitude = -43.1729f,
BirthDate = new DateTime(2006, 12, 5),
AccessLevel = AccessLevel.Admin
},
new Monkey
{
Name = "Proboscis Monkey",
Location = "Borneo",
Details = "Proboscis monkeys have large noses and are excellent swimmers.",
Image = "proboscis_monkey.jpg",
Population = 700,
Latitude = 2.4604f,
Longitude = 115.3502f,
BirthDate = new DateTime(2003, 4, 30),
AccessLevel = AccessLevel.User
},
// Add more monkey instances as needed
// ...
};
dxg.ItemsSource = new ObservableCollection<Monkey>(monkeys);
}
public class Monkey
{
public string Name { get; set; }
public string Location { get; set; }
public string Details { get; set; }
public string Image { get; set; }
public int Population { get; set; }
public float Latitude { get; set; }
public float Longitude { get; set; }
public AccessLevel AccessLevel { get; set; }
public DateTime BirthDate { get; set; }
}
public enum AccessLevel
{
Admin,
User
}
}
}
Full Code:
Demo
Download Code:
You can download the code from
GitHub. If you have
any doubts, feel free to post a comment. If you liked this article, and it is
useful to you, do like, share the article & star the repository on
GitHub.
Welcome to our latest blog post, where we delve into the dynamic world of app
development using .NET MAUI! In this comprehensive guide, we explore the
intricacies of the "DataGrid Control for .NET MAUI," an exceptional free
plugin designed to streamline your data management process. Discover how this
plugin empowers developers to effortlessly sort, filter, and display data,
enhancing user experiences within cross-platform applications.
In our latest article, we unveil the power of the "DataGrid Control for .NET
MAUI," an invaluable plugin that simplifies the complexities of data
management in cross-platform app development. As the demand for seamless data
visualization and interaction grows, this free plugin emerges as a
game-changer for .NET MAUI enthusiasts.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Install Plugin:
In this steps, we will see the steps to install "akgul.Maui.DataGrid" in Visual
Studio 2022:
Access NuGet Package Manager: In Visual Studio, right-click on your
.NET MAUI project in the Solution Explorer. From the context menu, select
"Manage NuGet Packages."
Search for "akgul.Maui.DataGrid": In the NuGet Package Manager, click
on the "Browse" tab. In the search bar, type "akgul.Maui.DataGrid" and hit
Enter. The package should appear in the search results.
Select and Install the Package: Once you find "akgul.Maui.DataGrid"
in the search results, click on it to select it. Ensure you choose the
appropriate version compatible with your .NET MAUI project. Click on the
"Install" button to begin the installation process.
Accept License Agreement: During the installation, you may be
prompted to accept the license agreement. Review the terms and conditions
and click on the "Accept" button to proceed.
Wait for Installation to Complete: Visual Studio will download and
install the package along with its dependencies. This process may take a few
moments, depending on your internet connection speed.
Verify Installation: After the installation is complete, verify that
there are no error messages in the Output window. This indicates a
successful installation of the "akgul.Maui.DataGrid" package.
Implementation
Add Namespace in XAML:
In your .NET MAUI XAML files where you intend to use the DataGrid, make sure
to add the appropriate XML namespace. For example:
The above code snippet represents a DataGrid component in .NET MAUI
application. Let's break down the properties and their meanings in the context
of this DataGrid:
RefreshingEnabled="True": Indicates that the DataGrid supports
pull-to-refresh functionality. Users can pull down to refresh the data
displayed in the grid.
BackgroundColor="White": Sets the background color of the entire
DataGrid component to white.
IsRefreshing="{Binding Refreshing}": Binds the IsRefreshing property
of the DataGrid to a boolean property named "Refreshing" in the underlying
ViewModel. This property likely controls the visual indication of whether
the DataGrid is currently refreshing data.
PullToRefreshCommand="{Binding OnDataGridRefreshCommand}": Binds the
pull-to-refresh action to a command named "OnDataGridRefreshCommand" in the
ViewModel. This command is executed when the user performs a pull-to-refresh
gesture.
SelectionEnabled="True": Allows users to select rows in the DataGrid.
SelectedItem="{Binding SelectedItem}": Binds the selected item in the
DataGrid to a property named "SelectedItem" in the ViewModel. This property
holds the currently selected item in the grid.
RowHeight="70": Sets the height of each row in the DataGrid to 70
units.
HeaderHeight="70": Sets the height of the header row in the DataGrid
to 70 units.
ItemsSource="{Binding Items}": Binds the DataGrid to a collection of
items represented by the "Items" property in the ViewModel. Each item in
this collection corresponds to a row in the DataGrid.
HeaderBackground="Red": Sets the background color of the header row
to red.
dg:DataGrid.NoDataView: Defines a custom view to be displayed when
there is no data to show in the DataGrid. In this case, a Label with the
text "Nothing to see here" is centered both horizontally and vertically.
dg:DataGrid.Columns: Specifies the columns to be displayed in the
DataGrid.
dg:DataGrid.RowsBackgroundColorPalette: Defines a color palette for
alternating row colors in the DataGrid.
This code snippet configures a DataGrid component with specific properties and
templates, allowing users to view and interact with data in a visually appealing
manner.
The Code Behind or MVVM view model properties are similar to listview control
and no specific code required
Full Code:
Demo
Download Code:
You can download the code from
GitHub. If you have
any doubts, feel free to post a comment. If you liked this article, and it is
useful to you, do like, share the article & star the repository on
GitHub.
.NET MAUI, a cross-platform framework, empowers developers to build native
mobile and desktop applications using C# and XAML. It enables the creation of
apps that seamlessly operate on Android, iOS, macOS, and Windows, all from a
unified codebase. This open-source platform is an advancement of Xamarin
Forms, expanding its reach to desktop scenarios while enhancing UI controls
for improved performance and extensibility.
In this article, we will see how to use SwipeView in .NET MAUI project.
SwipeView is a container control that wraps around an item of content,
and provides context menu items that are revealed by a swipe gesture.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Implementation
SwipeView defines the following attributes:
LeftItems: This property, of type SwipeItems, represents the swipe
items accessible when swiping the control from the left side.
RightItems: This property, of type SwipeItems, represents the swipe
items accessible when swiping the control from the right side.
TopItems: This property, of type SwipeItems, represents the swipe
items accessible when swiping the control from top to bottom.
BottomItems: This property, of type SwipeItems, represents the swipe
items accessible when swiping the control from bottom to top.
Threshold: This property, of type double, determines the number of
device-independent units required to trigger a swipe gesture and fully
reveal swipe items.
The SwipeView class additionally introduces three events:
SwipeStarted: This event is triggered when a swipe commences. It is
accompanied by a SwipeStartedEventArgs object that includes a property named
SwipeDirection of type SwipeDirection.
SwipeChanging: Raised during the progression of a swipe, the SwipeChanging
event provides a SwipeChangingEventArgs object. This object encompasses a
SwipeDirection property of type SwipeDirection and an Offset property of
type double.
SwipeEnded: When a swipe concludes, the SwipeEnded event is raised. Its
accompanying SwipeEndedEventArgs object contains a SwipeDirection property
of type SwipeDirection and an IsOpen property of type bool.
Here's an example demonstrating how to create a SwipeView in XAML.
You can download the code from
GitHub. If you have any
doubts, feel free to post a comment. If you liked this article, and it is
useful to you, do like, share the article & star the repository on
GitHub.
.NET MAUI, a cross-platform framework, empowers developers to build native
mobile and desktop applications using C# and XAML. It enables the creation of
apps that seamlessly operate on Android, iOS, macOS, and Windows, all from a
unified codebase. This open-source platform is an advancement of Xamarin
Forms, expanding its reach to desktop scenarios while enhancing UI controls
for improved performance and extensibility.
Mopups is a replacement for the "Rg.Plugins.Popups" plugin for Xamarin. Mopups intends to provide a similar experience to this plugin, however also clean up the code base and provide forward looking enhancements.
In this article, we will see how we can see the alternative to Rg.Plugin.Popup - MOPUP Page in .NET MAUI project.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Install Plugins:
Open Nuget Package Manager. Search MOPUPS and click install to the install the plugins in the projects.
Implementation
Initialize Mopups
In your MauiProgram.cs file, inside the CreateMauiAppBuilder method, include a call to .ConfigureMopups() on the host builder to set up the Mopups library:
using Mopups;
// ...
public static MauiApp CreateMauiAppBuilder()
{
var builder = MauiApp.CreateBuilder();
// Other configurations
builder.ConfigureMopups();
builder.Services.AddSingleton<IPopupNavigation>(MopupService.Instance);
builder.Services.AddTransient<MainPage>();
return builder.Build();
}
Create a Custom PopupPage
Include a new ContentPage in your project and update the base class of the XAML file to PopupPage. Don't forget to add the required namespace declaration for the Mopups.Pages namespace:
<?xml version="1.0" encoding="utf-8" ?>
<mopup:PopupPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:local="clr-namespace:YourNamespace"
xmlns:mopup="clr-namespace:Mopups.Pages;assembly=Mopups"
x:Class="YourNamespace.YourPopupPage">
<!-- Your PopupPage content goes here -->
</mopup:PopupPage>
Create and Display the Popup
Open MainPage.xaml.cs add the event to open the popup like below.
public partial class MainPage : ContentPage
{
IPopupNavigation popupNavigation;
public MainPage(IPopupNavigation popupNavigation)
{
InitializeComponent();
this.popupNavigation = popupNavigation;
}
private void OnCounterClicked(object sender, EventArgs e)
{
popupNavigation.PushAsync(new MyPopupPage());
}
}
Add the following code to close the popup screen
MopupService.Instance.PopAsync();
Full Code:
Demo
Download Code:
You can download the code from
GitHub. If you have
any doubts, feel free to post a comment. If you liked this article, and it
is useful to you, do like, share the article & star the repository on
GitHub.
You might have noticed that in many Android apps, you need to tap the back button twice to exit. When you tap it once, a message pops up. But if you tap it twice at the same time, you can close the app.
Before Android 13 (which is like the newest version), we used to make this work by changing how the back button behaves in the main part of the app (we call it "MainActivity"). But now, with Android 13, the way we used to do this is not recommended anymore. They have a new method that's better.
Launch Visual Studio 2022, and in the start window click Create a new
project to create a new project.
In the Create a new project window, select MAUI in the All project types
drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a
suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows
and other running options in the toolbar. Press the emulator or run button
to build and run the app
Implementation
This new method lets you see what will happen if you press the back button before you actually do it. This helps you decide if you want to go back or not. For example, you might choose to stay in the app, go back to the Home screen, or return to a previous page in a web browser.
To use this new method, Android 13 has added something called the "OnBackInvokedCallback". This is like a tool that helps you do this new back button behavior. It takes the place of the old way we used to change the back button behavior.
Now, instead of using the old way, we have the "OnBackPressedDispatcher" which takes care of handling when you press the back button. It works with the new method we just talked about.
class BackPress : OnBackPressedCallback
{
private readonly Activity activity;
private long backPressed;
public BackPress(Activity activity) : base(true)
{
this.activity = activity;
}
public override void HandleOnBackPressed()
{
var navigation = Microsoft.Maui.Controls.Application.Current?.MainPage?.Navigation;
if (navigation is not null && navigation.NavigationStack.Count <= 1 && navigation.ModalStack.Count <= 0)
{
const int delay = 2000;
if (backPressed + delay > DateTimeOffset.UtcNow.ToUnixTimeMilliseconds())
{
activity.FinishAndRemoveTask();
Process.KillProcess(Process.MyPid());
}
else
{
Toast.MakeText(activity, "Close", ToastLength.Long)?.Show();
backPressed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
}
}
}
}
You'll want to take charge by overriding the HandleOnBackPressed method. The code inside this method closely resembles what you previously had in OnBackPressed.
In the last lap of this process, we're going to slot in this callback. You can achieve this by extending the OnCreate method of your MainActivity:
using Android.App;
using Android.Content.PM;
using Android.OS;
using Android.Widget;
using AndroidX.Activity;
namespace MauiOnBackPressed;
[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
public class MainActivity : MauiAppCompatActivity
{
protected override void OnCreate(Bundle? savedInstanceState)
{
base.OnCreate(savedInstanceState);
OnBackPressedDispatcher.AddCallback(this, new BackPress(this));
}
}
class BackPress : OnBackPressedCallback
{
private readonly Activity activity;
private long backPressed;
public BackPress(Activity activity) : base(true)
{
this.activity = activity;
}
public override void HandleOnBackPressed()
{
var navigation = Microsoft.Maui.Controls.Application.Current?.MainPage?.Navigation;
if (navigation is not null && navigation.NavigationStack.Count <= 1 && navigation.ModalStack.Count <= 0)
{
const int delay = 2000;
if (backPressed + delay > DateTimeOffset.UtcNow.ToUnixTimeMilliseconds())
{
activity.FinishAndRemoveTask();
Process.KillProcess(Process.MyPid());
}
else
{
Toast.MakeText(activity, "Close", ToastLength.Long)?.Show();
backPressed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
}
}
}
}
Download Code:
You can download the code from
GitHub. If you have
any doubts, feel free to post a comment. If you liked this article, and it
is useful to you, do like, share the article & star the repository on
GitHub.
Follow Us
Were this world an endless plain, and by sailing eastward we could for ever reach new distances