Category Archives: MAUI

MAUI setting the apps dimensions on a Windows Desktop

I have a MAUI application, designed to an extent as mobile-first. In other words it looks good on a mobile, phone or tablet device in full screen mode. But I really want the app to work and look good (on start up) on Windows Desktop. Ofcourse Windows will just give my main app window a size and I need to do whatever I can to ensure the app looks good.

It’s be so much simpler if I could just set the dimensions of my main window (at start up) to something that looks good. If the user resizes, that’s fine but just starting with a good default makes everything look better.

Okay so that’s the problem at hand, how to solve this?

The first thing is, I thought, I could just change the Platforms/Windows/App.xaml.cs, but nothing obvious there to allow this. If we look at App.xaml.cs we can override the CreateWindow method, so let’s do that – here’s the code

public partial class App : Application
{
  public App()
  {
    InitializeComponent();
    MainPage = new AppShell();
  }

  protected override Window CreateWindow(IActivationState? activationState)
  {
    var window = base.CreateWindow(activationState);

#if WINDOWS
    if (DeviceInfo.Idiom == DeviceIdiom.Desktop)
    {
      window.Width = 500;
      window.Height = 700;
    }
#endif

    return window;
  }
}

It’s pretty self-explanatory, we use conditional compilate using #if WINDOWS to only include the code for a Windows build, but as I also have a Windows tablet I figured I’d also check that the idiom is Desktop before I try to set the window dimensions. All pretty straight forward – although not quite.

The problem is that strangely ANDROID and the likes exist a defines, but seemingly not WINDOWS. We can fix this ourselves in one of two ways.

  • Open the .csproj file and for the net7.0-windowsxxx PropertyGroups add the following
    <DefineConstants>$(DefineConstants);WINDOWS</DefineConstants>
    
  • Open the project’s properties, locate the Build | General then for the “Conditional compilation symbols” for net7.0-windowsxxx entries, add
    $(DefineConstants);WINDOWS
    

This doesn’t fully solve things, well it does but Visual Studio will show the code in Create Window as grayed out as if the conditional compilation directive is excluding the code from the build – it’s not, but it looks that way.

Anyway, now we are able to size the main Window on Windows at start-up.

Plugin.Maui.Audio plays sound even if Android device is set to vibrate

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();
}

Android notifications using MAUI (Part 10 of 10)

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.

Android notifications using MAUI (Part 9 of 10)

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.

Android notifications using MAUI (Part 8 of 10)

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.

Android notifications using MAUI (Part 7 of 10)

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.

Android notifications using MAUI (Part 6 of 10)

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.

Android notifications using MAUI (Part 5 of 10)

So the last couple of posts started to look at using styles within the notifications. We’re actually going to continue in that vein by looking at the message style and also direct replies, i.e. a style where we get a text entry control in the notification. This cover the tutorial Notifications Tutorial Part 5 – MESSAGING STYLE + DIRECT REPLY – Android Studio Tutorial and unlike the previous couple of posts where the style only partially worked or didn’t work at all. This one worked as expected.

Overview

What we’re aiming to implement here is…

Imagine a chat application which ofcourse might go into the background and yet we want to notify the user when a message appears and allow them to reply to that message via the notification.

We’ll start by adding our message type and our database to store the messages (okay a simple collection, not a database).

First off, add a new class named Message to the Platforms/Android folder/namespace. Ofcourse, as I’ve mentioned previously, this is just the simplest way to do this, obviously we’d have this as a service etc. in a real world application, anyway the Message class looks like this

public class Message
{
    public Message(string text, string sender)
    {
        Text = text;
        Sender = sender;
        // The Timestamp is required for the NotificationCompat.MessagingStyle.Message object, so we'll just generate here
        Timestamp = DateTime.Now.Millisecond; // prob. doesn't do the same as the Java example, need to check System.currentTimeMillis()
    }

    public string Text { get; }
    public long Timestamp { get; }
    public string Sender { get; }
}

It should be self-explanatory apart from the Timestamp, this is required later in our NotificationCompat.MessageStyle.Message – we could create it when that’s called or when the message is created.

We’re going to be a little naughty here (again to keep things simple) by making our SendOnChannel1 a static method. The reason we’re doing this is that we need to create a BroadcastReceiver to allow us to reply to messages and it needs to call the notification channel to update it. So, let’s jlook at the current state of this method, but first let’s add our pretend database to the MainActivity like this

public static List<Message> Messages = new List<Message>();

We now want to just prepopulate our messages, so in the MainActivity constructor add

Messages.Add(new Message("Good morning!", "Jim"));
// null will be from us, and hence will use the "Me" from the messaging style
Messages.Add(new Message("Hello", null)); 
Messages.Add(new Message("Ji!", "Jenny"));

and now to the SendOnChannel1 changes (well I’ll just show the whole method as it’s almost all changed)

public static void SendOnChannel1(Context context)
{
  var activityIntent = new Intent(context, typeof(MainActivity));
  var contentIntent = PendingIntent.GetActivity(context, 0, activityIntent, 0);

  var remoteInput = new RemoteInput.Builder("key_text_reply")
    .SetLabel("Your answer...")
    .Build();

  PendingIntent replyPendingIntent = null;

  if (Build.VERSION.SdkInt >= BuildVersionCodes.N)
  {
    var replyIntent = new Intent(context, typeof(DirectReplyReceiver));
    replyPendingIntent = PendingIntent.GetBroadcast(context, 0, replyIntent, 0);
  }
  else
  {
    // older versions of Android 
    // start activity instead PendingIntent.GetActivity()
    // cancel notification with notificationManagerCompat.Cancel(id)
  }

  var replyAction = new NotificationCompat.Action.Builder(Resource.Drawable.AppIcon, "Reply", replyPendingIntent)
    .AddRemoteInput(remoteInput)
    .Build();

  var messagingStyle = new NotificationCompat.MessagingStyle("Me");
  messagingStyle.SetConversationTitle("Group Chat");

  foreach(var chatMessage in Messages)
  {
    var notificationMessage =
      new NotificationCompat.MessagingStyle.Message(
        chatMessage.Text, 
        chatMessage.Timestamp,
        chatMessage.Sender);
    messagingStyle.AddMessage(notificationMessage);
  }

  var notification = new NotificationCompat.Builder(context, MainApplication.Channel1Id)
    // mandatory
    .SetSmallIcon(Resource.Drawable.abc_ab_share_pack_mtrl_alpha)
    .SetStyle(messagingStyle)
    .AddAction(replyAction)
    .SetColor(Colors.Blue.ToInt())
    .SetPriority(NotificationCompat.PriorityHigh)
    .SetCategory(NotificationCompat.CategoryMessage)
    .SetContentIntent(contentIntent)
    // when we tap the notification it will close
    .SetAutoCancel(true)
    // only show/update first time
    .SetOnlyAlertOnce(true)
    .Build();

  var notificationManager = NotificationManagerCompat.From(context);
  notificationManager.Notify(1, notification);
}

There’s a lot to take in there. The first obvious different (other than the method going static) is the use of RemoteInputBuilder. The remote builder takes a key (a string) which we use later to retrieve the input from. The “Your answer…” text is what will be displayed as a hint in the reply text entry that we’ll being implementing.

Next we have some code to ensure the correct version of Android is being targeted (I don’t have code for a previous version, so I assume if the correct version or above is not being used then this feature is not available). In here we create the received for replies via our notification. So you can see we create a broadcast intent which we pass into our replyAction. Notices how in the previous RemoteInputBuilder code we also have a key key_text_reply this is used in the reciever, as we’ll see later.

We then create an the replyAction which will become our action when the user replies to a message.

Next, we supply the current messages to the notification, i.e. to pre-populate and update the list of messages. Then NotificationCompat.Builder is probably self-explanatory now.

Oh I almost forgot, in the code above we also have the usage of typeof(DirectReplyReceiver) this will handle the reply text etc. So create yourself a class named DirectReplyReceiver which should look like this

[BroadcastReceiver(Enabled = true, Exported = false)]
public class DirectReplyReceiver : BroadcastReceiver
{
    public override void OnReceive(Context context, Intent intent)
    {
        var remoteInput = RemoteInput.GetResultsFromIntent(intent);
        if (remoteInput != null)
        {
            var replyText = remoteInput.GetCharSequence("key_text_reply");
            var answer = new Message(replyText, null);
            MainActivity.Messages.Add(answer);

            // without calling this the message will get added to the Messages but left in limbo
            // the reply will look like it's stuck sending a message (i.e. spinning progress bar and no updates)
            MainActivity.SendOnChannel1(context);
        }
    }
}

In the OnReceive we get the intent value using the key_text_reply key to get the text the user entered then for our demo we add it to the messages collection to update the notification. We need to then call SendOnChannel1 again to get it to complete updating of the notifications.

Code

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

Android notifications using MAUI (Part 4 of 10)

Extending on what we did in “Android notifications using MAUI (Part 3 of 10)” we’re going to look an nig text style and inbox style as per Notifications Tutorial Part 4 – BIG PICTURE STYLE + MEDIA STYLE – Android Studio Tutorial.

Overview

This is not a very useful post as I again found that either I’m missing something or there’s issues in MAUI, for the sake of argument I’ll assume it’s my fault. Anyway I’m still going to show how (I think) you can display a larger bitmap as well as apply the MediaStyle which has the ability to handle up to five actions
(obviously useful for play, pause, back, forward etc.) as well as three actions in a collapsed state.

In the SendOnChannel1 method from our previous posts, we’ll add a BigPictureStyle to our NotificationCompat.Builder like this, to begin with I’ve just renamed the variable as per the tutorial video

var picture = BitmapFactory.DecodeResource(Android.App.Application.Context.Resources, Resource.Drawable.AppIcon);

Now we add the style like this

.SetStyle(new NotificationCompat
  .BigPictureStyle()
  .BigPicture(picture)
  .BigLargeIcon(null))

Note: Again I’m having trouble with the bitmap side of things, i.e. not displaying on the emulator. I will update here if I find it’s something I’ve done incorrectly. What you will see is a larger notification when you expand the notifications via the status bar, presumably to accommodate my picture

Let’s now create a pretend media play or at least the actions for one on channel 2 notifications. As such I added PNG’s to Platforms/Android/Resources/drawable for like, dislike, next, pause, previous actions.

We need to update our SendOnChannel2 method to add the following actions

.AddAction(Resource.Drawable.dislike, "Dislike", null)
.AddAction(Resource.Drawable.previous, "Previous", null)
.AddAction(Resource.Drawable.pause, "Pause", null)
.AddAction(Resource.Drawable.next, "Next", null)
.AddAction(Resource.Drawable.like, "Like", null)

Nothing too much different there apart from I’m not bothering to set intents for the actions (i.e. they do nothing). Now we need to set the style to MediaStyle and here we supply three indexes (zero-based) into our actions to denote the actions available when the notification is not expanded.

.SetStyle(new AndroidX.Media.App.NotificationCompat.MediaStyle()
  // the id's for the actions listed as actions
  .SetShowActionsInCompactView(1, 2, 3) 
  /*.SetMediaSession(_mediaSession.SessionToken)*/) 

As you can I’ve commented out the SetMediaSession (which is shown in the code listed at the end of this post) – I wasn’t able to get this to work as per the tutorial video, when declaring it in the constructor I was getting a JNI failure – again this might be something I’ve done wrong, so best to take a look at the source code on my repos. and decide what to do with this.

Code

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

Android notifications using MAUI (Part 3 of 10)

Extending on what we did in “Android notifications using MAUI (Part 2 of 10)” we’re going to look at adding text style and inbox style as per Notifications Tutorial Part 3 – BIG TEXT STYLE + INBOX STYLE – Android Studio Tutorial.

Overview

We’re going to continue using the code we implemented in the last part of this set of posts. We’re going to add a large icon to the notification as well using some built-in styling to style our notification. We’ll also use another style for our channel 2 notifications called the InboxStyle which will display messages more like a list.

Before we get into this the code for setting the large icon does not appear to work correctly and as mentioned in part 1 of this series of posts, some styles don’t seem to work as expected in general, but we’ll go through the process of writing the code and maybe I can return to in the future if I find a way to get things to work.

Let’s get started

To add an icon to the Android resources, go to Platforms/Android/Resources and add a folder named drawables. Within this add a .PNG. I’m using my application’s icon which I exported/saved to a .PNG. My file is named AppIcon.png.

Now, in the MainActivity.SendOnChannel1 method, before we create the notification add the following line

var largeIcon = BitmapFactory.DecodeResource(
   Android.App.Application.Context.Resources, Resource.Drawable.AppIcon
);

Notice how our AppIcon is accessible (or will be when you build the project) from Resource.Drawable.AppIcon in other words the filename excluding the extension becomes our resource id. To use this icon we need to pass a bitmap to the SetLargeIcon method, hence we’re using the BitmapFactory to decode the resource.

Now, if we add the following to the notification builder we should see a large icon displayed alongside the message

.SetLargeIcon(largeIcon)

Remember that a small icon is required for a notification. The large icon is not required. Let’s also change our small icon to use the same icon, so change SetSmallIcon to this

.SetSmallIcon(Resource.Drawable.AppIcon)

Next we want to change our notification style. This is done through SetStyle and we can supply different built-in styles, so the code for this looks like this (added to the NotificationCompat.Builder)

.SetStyle(new NotificationCompat
                .BigTextStyle()
                .BigText("Some Big Text")
                .SetBigContentTitle("Big Content Title")
                .SetSummaryText("Summary Text"))

Lastly we’ll display the messages in channel 2 using the InboxStyle, which will allows us to add up to seven lines, like a list. To add this go to SendOnChannel2 and add the following code

.SetStyle(new NotificationCompat
  .InboxStyle()
    .AddLine("This is line 1")
    .AddLine("This is line 2")
    .AddLine("This is line 3")
    .SetBigContentTitle("Big Content Title")
    .SetSummaryText("Summary Text"))

Code

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