I have a MAUI application which alerts the user with a sound and vibration when a task is completed. I noticed that turning the phone to vibrate didn’t actually stop the sound being played via the Plugin.Maui.Audio (as I sort of expected it to do).

It looks like what we need to do is write some Android specific code to check the Android AudioManager’s RingerMode.

If we assume we have a device independent enum such as the following (this simply mirrors the Android RingerMode)

public enum AudioMode
{
    Silent = 0,
    Vibrate = 1,
    Normal = 2
}

Now, from our Android code we would expose the RingerMode like this

if (Context.GetSystemService(AudioService) is not AudioManager audioService)
  return AudioMode.Normal;

switch (audioService.RingerMode)
{
  case RingerMode.Normal:
    return AudioMode.Normal;
  case RingerMode.Silent:
    return AudioMode.Silent;
  case RingerMode.Vibrate:
    return AudioMode.Vibrate;
}

return AudioMode.Normal;

Now we would simply wrap our Plugin.Maui.Audio code in an if statement, checking the AudioMode of the device. i.e. if Vibrate or Silent, don’t play the audio. For example

if (_deviceAudioService.AudioMode == AudioMode.Normal)
{
  var audioPlayer =
    _audioManager.CreatePlayer(await FileSystem.OpenAppPackageFileAsync("chimes.wav"));
  audioPlayer.Volume = Math.Clamp(_configuration.NotificationSoundVolume / 100.0, 0, 1);
  audioPlayer.Play();
}

In this post we’re going to cover the tutorial Notifications Tutorial Part 10 – DELETE NOTIFICATION CHANNELS – Android Studio Tutorial and we’re going to be look at deleting notification channels.

Overwrite

We can delete notification channels if they’re no longer required, so let’s create some code by changing the UI slightly and updating with a new message – ofcourse in a real-world scenario, it’s more likely you’re either deleting a channel that’s been dynamically created or deleting a legacy channel.

Implementation

Go to to MainPage.xaml and add

<Button Text="Delete Channels" Clicked="DeleteChannel_OnClick" Margin="10" />

In the code behind MainPage.xaml.cs add the following

private void DeleteChannel_OnClick(object sender, EventArgs e)
{
  _messenger.Send(new DeleteChannelData());
}

As you can see we’ve added a new class DeleteChannelData to be sent to anything that wishes to listen to tell them to delete a channel. The code for this is simply

public record DeleteChannelData;

(It’s just really the equivalent of a command).

In the Android MainActivity constructor, add

messenger.Register<DeleteChannelData>(this, (recipient, message) =>
{
  if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
  {
    if (GetSystemService(NotificationService) is NotificationManager manager)
    {
      // hard coded to delete channel 3
      //manager.DeleteNotificationChannel(MainApplication.Channel3Id);
      manager.DeleteNotificationChannelGroup(MainApplication.Group1Id);
    }
  }
});

So this receives the DeletChannelData message and deletes either channel 3 (commented out) or a given group via the NotificationManager. Notice this is NOT the NotificationManagerCompat.

Now if you run this (after running the version prior to this) and go to the settings page for your application’s notifications (Settings | Apps & notifications) you’ll noticed it says something like 2 categories deleted if you’re deleting Group1Id group. This is telling the user that something deleted the channels.

Code

Code for this an subsequent posts is found on my blog project.

In this post we’re going to cover the tutorial Notifications Tutorial Part 9 – NOTIFICATION CHANNEL SETTINGS – Android Studio Tutorial and we’re going to be notification channel settings.

Overwrite

In a previous post we looked at the fact that we cannot change the notification settings once created, we need to uninstall and reinstall. This is ofcourse not a lot of help if, whilst our application is running it determines that the user should be given the opportunity to change a setting. For example let’s assume the user blocked a channel and now wants our application to notify them when something occurs within the application.

Ofcourse we could popup an alert saying “Go to the channel settings and unblock it” or better still we can alert them then display the settings.

Implementation

We’re going to change our MainActivity.SendOnChannel1 method to check if notifications are enabled and whether they’re blocked. So let’s first look at how we check if notifications are enabled.

We need access to the NotificationManagerCompat and we use it like this

if (!notificationManager.AreNotificationsEnabled())
{
  OpenNotificationSettings(context);
  return;
}

In this case we’re not even bothering to try to send notifications if they’re disabled, but we use our new method OpenNotificationSettings to show the settings screen (in a real world app we’d probably display and alert to asking them if they wish to change the settings etc.

[RequiresApi(Api = 26)]
private static void OpenNotificationSettings(Context context)
{
  // api 26
  if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
  {
    var intent = new Intent(Settings.ActionAppNotificationSettings);
    intent.PutExtra(Settings.ExtraAppPackage, context.PackageName);
    context.StartActivity(intent);
  }
  else
  {
    var intent = new Intent(Settings.ActionApplicationDetailsSettings);
    intent.SetData(Uri.Parse($"package:{context.PackageName}"));
    context.StartActivity(intent);
  }
}

Next in SendOnChannel1 we’re execute this code to check if the specific channel is blocked and again alert/open settings for the user if it is

if (Build.VERSION.SdkInt >= BuildVersionCodes.O && IsChannelBlocked(context, MainApplication.Channel1Id))
{
  OpenChannelSettings(context, MainApplication.Channel1Id);
  return;
}

IsChannelBlocked looks like this

[RequiresApi(Api = 26)]
private static bool IsChannelBlocked(Context context, string channelId)
{
  if (context.GetSystemService(NotificationService) is NotificationManager manager)
  {
    var channel = manager.GetNotificationChannel(channelId);
    return channel is { Importance: NotificationImportance.None };
  }

  return false;
}

Note that both these methods require API 21 or above.

Code

Code for this an subsequent posts is found on my blog project.

In this post we’re going to cover the tutorial Notifications Tutorial Part 8 – NOTIFICATION CHANNEL GROUPS – Android Studio Tutorial and we’re going to be notification channel groups

Overwrite

In the previous post we looked at notifications being grouped into summaries. We also have the concept of grouping notification channels themselves. These are ways of, for example, grouping your channels themselves by some business or logical grouping – maybe you group channels by importance or by business process or multiple user accounts etc.

Basically this allows us to fine grain our channels allowing the user to change settings to those groups.

Implementation

In MainApplication.cs just update our channel id’s etc. to look like this

public const string Group1Id = "group1";
public const string Group2Id = "group2";
public const string Channel1Id = "channel1";
public const string Channel2Id = "channel2";
public const string Channel3Id = "channel3";
public const string Channel4Id = "channel4";

We’ve got a couple of extra channels as well as some group id’s. Now change our OnCreate method to look like this

public override void OnCreate()
{
  base.OnCreate();

  if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
  {
#pragma warning disable CA1416
    var group1 = new NotificationChannelGroup(Group1Id, "Group 1");
    var group2 = new NotificationChannelGroup(Group2Id, "Group 2");

    var channel1 = new NotificationChannel(Channel1Id, "Channel 1", NotificationImportance.High);
    channel1.Description = "This is Channel 1";
    channel1.Group = Group1Id;

    var channel2 = new NotificationChannel(Channel2Id, "Channel 2", NotificationImportance.Low);
    channel2.Description = "This is Channel 2";
    channel2.Group = Group1Id;

    var channel3 = new NotificationChannel(Channel3Id, "Channel 3", NotificationImportance.High);
    channel3.Description = "This is Channel 3";
    channel3.Group = Group2Id;

    var channel4 = new NotificationChannel(Channel4Id, "Channel 4", NotificationImportance.Low);
    channel4.Description = "This is Channel 4";    
    // purposefully no group

    if (GetSystemService(NotificationService) is NotificationManager manager)
    {
      manager.CreateNotificationChannelGroup(group1);
      manager.CreateNotificationChannelGroup(group2);

      manager.CreateNotificationChannel(channel1);
      manager.CreateNotificationChannel(channel2);
      manager.CreateNotificationChannel(channel3);
      manager.CreateNotificationChannel(channel4);
    }
#pragma warning restore CA1416
  }
}

As you can see, we’ve create two group channels and then assigned these, where required, to our notification channels (i.e. .Group = Group1Id etc.). That’s it.

Now if we run this application, go to the Android Settings | App & notifications click on our application name then select Notifications we’re see our channels grouped together in Group 1, Group 2 and channel 4 is not grouped, so become “Other”.

Code

Code for this an subsequent posts is found on my blog project.

In this post we’re going to cover the tutorial Notifications Tutorial Part 7 – NOTIFICATION GROUPS – Android Studio Tutorial and we’re going to be adding a notification groups to our channel 2 code.

Overview

In this code we’re going to send notifications to a group. They will initially appear as different notifications but will then get grouped together.

Implementation

We’re going to overwrite/reuse our SendOnChannel2 method, first we’ll create two separate notifications but assign them to the same group, like this

var notification1 = new NotificationCompat.Builder(this, MainApplication.Channel2Id)
  .SetSmallIcon(Resource.Drawable.abc_btn_check_material)
  .SetContentTitle("Title 1")
  .SetContentText("Message 1")
  .SetPriority(NotificationCompat.PriorityLow)
  .SetGroup("example_group")
  .Build();

var notification2 = new NotificationCompat.Builder(this, MainApplication.Channel2Id)
  .SetSmallIcon(Resource.Drawable.abc_btn_check_material)
  .SetContentTitle("Title 2")
  .SetContentText("Message 2")
  .SetPriority(NotificationCompat.PriorityLow)
  .SetGroup("example_group")
  .Build();

We’re created the example_group but other than that you should be familiar with the way we create notifications.

Next we need a notification to become the summary notification (i.e. displays altogether in the same group) as these notification currently will simply be displays as two distinct notifications. So we add another notification like this

var summaryNotification = new NotificationCompat.Builder(this, MainApplication.Channel2Id)
  .SetSmallIcon(Resource.Drawable.abc_btn_colored_material)
  .SetStyle(new NotificationCompat.InboxStyle()
    .AddLine("Title 2 Message 2")
    .AddLine("Title 1 Message 1")
    .SetBigContentTitle("2 new messages")
    .SetSummaryText("user@example.com"))
  .SetPriority(NotificationCompat.PriorityLow)
  .SetGroup("example_group")
  .SetGroupAlertBehavior(NotificationCompat.GroupAlertChildren)
  .SetGroupSummary(true)
  .Build();

The main lines to look at are the last three. Again we set the group to the same as the other notifications but now we give this one a different alter behaviour and set it to become the group summary.

Finally let’s simulate messages arriving then see the grouping happen, so add the following the the method

Thread.Sleep(2000);
_notificationManager.Notify(2, notification1);
Thread.Sleep(2000);
_notificationManager.Notify(3, notification2);
Thread.Sleep(2000);
_notificationManager.Notify(4, summaryNotification);

Again a warning, this is not (as hopefully is obvious) good real world practise, for starters this method may be called on the main thread, depending upon your implementation and hence block that thread.

Code

Code for this an subsequent posts is found on my blog project.

In this post we’re going to cover the tutorial Notifications Tutorial Part 6 – PROGRESS BAR NOTIFICATION – Android Studio Tutorial and we’re going to be adding a progress bar to our notification.

Overview

You may have a requirement to show a progress bar notification, for example a process to download a file or the likes takes place, your application goes into the background but we keep getting feedback via the notification’s progress bar.

Implementation

We’ll leave channel 1 for now and simply add our progress bar to SendOnChannel2. We’ll change the content title to “Download” and content text “Download in progress), we’ll add a progress bar to the notification and set it’s max and current value. The progress bar will be determinate i.e. it’s not one of those progress bars that bounces back and forth indeterminate.

We’re also going to simulate updates to the progress bar within this method. Let’s look at the SendOnChannel2 method

const int progressMax = 100;
var notification = new NotificationCompat.Builder(this, MainApplication.Channel2Id)
   .SetSmallIcon(Resource.Drawable.abc_btn_check_material)
   .SetContentTitle("Download")
   .SetContentText("Download in progress")
   .SetPriority(NotificationCompat.PriorityLow)
   .SetOngoing(true)
   .SetOnlyAlertOnce(true) // with high priority, stops the popup on every update
   .SetProgress(progressMax, 0, false);

   _notificationManager.Notify(2, notification.Build());

   // simulate progress, such as a download
   Task.Run(() =>
   {
      Thread.Sleep(2000);

      for (var progress = 0; progress <= progressMax; progress += 10)
      {
         notification.SetProgress(progressMax, progress, false);
         // same id (2) to ensure overwrite/updates existing
         _notificationManager.Notify(2, notification.Build());

         Thread.Sleep(1000);
      }

      notification.SetContentText("Download finished")
         .SetOngoing(false)
         .SetProgress(0, 0, false);

      // same id (2) to ensure overwrite/updates existing
      _notificationManager.Notify(2, notification.Build());
   });

This is pretty simple and hopefully fairly sel-explanatory. But to summarise, we add a progress bar, set it’s starting point then in a separate thread, pause for a bit, so the user would see the download simulation start, then update the progress bar and pause to just make it look like it’s busy downloading something. All this happens against the same notification id, hence updates the current progress. Eventually we finish the download simulation and update the progress bar to show this completed state.

Code

Code for this an subsequent posts is found on my blog project.