Xamarin Forms Push Notification Complete Guide

Prerequisites:

1. Visual Studio 2019 or later.
2. Basic knowledge of Xamarin.Forms.
3. An active Google account (to register apps for FCM).

Step 1: Create a New Xamarin.Forms Project

1. Open Visual Studio and create a new project.
2. Go to "Create a new project", select "Mobile App (.NET MAUI)" or "Xamarin.Forms App".
3. Follow the wizard to name your project and choose a location to save it.
4. Select an “App template” and platform targets according to your preference. For this example, we'll focus on Android and iOS.

Step 2: Set Up Firebase Console

For Android:

1. Visit Firebase Console.
2. Click on "Add Project" and follow the instructions.
3. Once the project is created, click "Android" and register your app.
4. Download the google-services.json file and add it to the Assets folder in your Android project.
5. Make sure google-services.json is included in the Android project using properties (Build Action must be set to GoogleServicesJson).

For iOS:

1. In the Firebase console, click "iOS" and register your app.
2. Download the GoogleService-Info.plist file and add it to the Resources folder of your iOS project.
3. Make sure GoogleService-Info.plist is included in the iOS project (Build Action should be set to BundleResource).

Step 3: Install Required NuGet Packages

Install the following NuGet packages:

• Xamarin.Firebase.Messaging - for Android
• Xamarin.Firebase.iOS.CloudMessaging - for iOS

You can find these packages via the NuGet Package Manager in Visual Studio for each of your Android and iOS projects respectively.

Step 4: Implement Push Notifications in Android

a. Configure AndroidManifest

In your Android project's Properties folder, open AndroidManifest.xml. Add the following inside the <application> tag:

<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver" android:exported="false" />
<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
        <action android:name="com.google.android.c2dm.intent.RECEIVE" />
        <category android:name="${applicationId}" />
    </intent-filter>
</receiver>

<service android:name=".MyFirebaseInstanceIdService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service>

<service android:name=".MyFirebaseMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>

b. Firebase Instance ID Service

Create a class named MyFirebaseInstanceIdService.cs in your Android project:

using Android.App;
using Android.Util;
using Firebase.Iid;

namespace YourNamespace.Droid
{
    [Service]
    public class MyFirebaseInstanceIdService : FirebaseInstanceIdService
    {
        const string TAG = "MyFirebaseIIDService";

        public override void OnTokenRefresh()
        {
            var refreshedToken = FirebaseInstanceId.Instance.Token;
            Log.Debug(TAG, "Refreshed token: " + refreshedToken);
            SendRegistrationToServer(refreshedToken);
        }

        void SendRegistrationToServer(string token)
        {
            // You would send the instance ID token to your app server here.
        }
    }
}

c. Firebase Messaging Services

Create another service named MyFirebaseMessagingService.cs:

using Android.App;
using Android.Content.Intents;
using Android.Util;
using Firebase.Messaging;

namespace YourNamespace.Droid
{
    [Service(Label = "MyFirebaseMessagingService")]
    public class MyFirebaseMessagingService : FirebaseMessagingService
    {
        const string TAG = "MyFirebaseMsgService";

        public override void OnMessageReceived(RemoteMessage message)
        {
            base.OnMessageReceived(message);
            Log.Debug(TAG, "From: " + message.From);
            Log.Debug(TAG, "Notification Message Body: " + message.GetNotification().Body);
            
            // Send notification data to the MainActivity
            SendNotification(message.GetNotification().Body);
        }

        private void SendNotification(string messageBody)
        {
            var intent = new Intent(this, typeof(MainActivity));
            intent.AddFlags(ActivityFlags.ClearTop);
            var pendingIntent = PendingIntent.GetActivity(this, 0, intent, PendingIntentFlags.OneShot);

            var notificationBuilder = new Notification.Builder(this)
                .SetSmallIcon(Resource.Drawable.ic_launcher_background)
                .SetContentTitle("FCM Message")
                .SetContentText(messageBody)
                .SetPriority(NotificationPriority.Max)
                .SetDefaults(NotificationDefaults.All)
                .SetAutoCancel(true)
                .setContentIntent(pendingIntent);

            var notificationManager = GetSystemService(Context.NotificationService) as NotificationManager;
            notificationManager.Notify(0, notificationBuilder.Build());
        }
    }
}

Step 5: Implement Push Notifications in iOS

a. AppDelegate Configuration

Modify your AppDelegate.cs in the iOS project to receive push notifications:

using Firebase.CloudMessaging;
using Firebase.InstanceID;
using UIKit;
using UserNotifications;

namespace YourNamespace.iOS
{
    [Register("AppDelegate")]
    public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate, IUNUserNotificationCenterDelegate, IMessagingDelegate
    {
       public override bool FinishedLaunching(UIApplication app, NSDictionary options)
        {
            SetupFirebase(app);
            LoadApplication(new App());

            return base.FinishedLaunching(app, options);
        }

        void SetupFirebase(UIApplication app)
        {
            if (IntPtr.Size != 8) // i386 emulators
            {
                GlobalFirebaseAppDelegate.Configure();
            }
            else
            {
                App.Configure();
            }

            // Register for push notifications
            if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0))
            {
                UNUserNotificationCenter.Current.Delegate = this;

                var authOptions = UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound;
                UNUserNotificationCenter.Current.RequestAuthorization(authOptions, (granted, error) =>
                {
                    Console.WriteLine(granted);
                });

                Messaging.SharedInstance.Delegate = this;
            }
            else
            {
                var settings = UIUserNotificationSettings.GetSettingsForTypes(
                    UIUserNotificationType.Alert | UIUserNotificationType.Badge | UIUserNotificationType.Sound,
                    new NSSet());

                UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
            }

            UIApplication.SharedApplication.RegisterForRemoteNotifications();
        }

        public void DidReceiveRegistrationToken(string registrationToken)
        {
            Console.WriteLine($"IID Registration Token: {registrationToken}");
        }

        public void DidReceiveMessage(MessagingDelegateEventArgs remoteMessage)
        {
            Console.WriteLine("FCM Message Body: " + remoteMessage.Message.Body);
            ShowAlert("Remote Message", remoteMessage.Message.Body);
        }

        void ShowAlert(string title, string messageBody)
        {
            if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0))
            {
                UNUserNotificationCenter.Current.AddNotificationRequest(
                    new UNNotificationRequest(
                        identifier: Guid.NewGuid().ToString(),
                        content: new UNMutableNotificationContent()
                        {
                            Title = title,
                            Body = messageBody,
                            Sound = UNNotificationSound.Default
                        },
                        trigger: UNNotificationTrigger.CreateNow()),
                    (error) => {
                        if (error != null)
                            Console.WriteLine($"Error: {error}");
                    });
            }
            else
            {
                UIAlertController alert = UIAlertController.Create(title, messageBody, UIAlertControllerStyle.Alert);
                alert.AddAction(UIAlertAction.Create("Ok", UIAlertActionStyle.Default, (aAction) => Console.WriteLine($"Alert dismissed: {remoteMessage.Message.Body}")));
               
                UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(alert, true, null);
            }
        }

        public override void FailedToRegisterForRemoteNotifications(UIApplication application, NSError error)
        {
            Console.WriteLine(error);
        }

        public override void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
        {
            Messaging.SharedInstance.ApnsToken = deviceToken;
        }
    }
}

Step 6: Add Shared Logic Between Platforms

Create a common interface to interact with push notifications in shared code.

a. Creating the Interface

public interface IPushNotification
{
    void Initialize();
    void RegisterDevice();
}

b. Implementing the Android Version

Create a platform-specific implementation in the Droid folder:

using Android.App;
using Android.OS;
using Firebase.InstanceID;

[assembly: Dependency(typeof(PushNotificationImplementation))]
namespace YourNamespace.Droid
{
    public class PushNotificationImplementation : IPushNotification
    {
        public async void Initialize()
        {
            var refreshedToken = await FirebaseInstanceId.Instance.GetTokenAsync();
            Console.WriteLine($"Current Token: {refreshedToken}");
        }

        public void RegisterDevice()
        {
            // This is already handled by FirebaseInstanceIdReceiver
        }
    }
}

c. Implementing the iOS Version

Similarly, for iOS:

using Firebase.CloudMessaging;
using UIKit;

[assembly: Dependency(typeof(PushNotificationImplementation))]
namespace YourNamespace.iOS
{
    public class PushNotificationImplementation : IPushNotification
    {
        public void Initialize()
        {
            if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0))
            {
                UNUserNotificationCenter.Current.RequestAuthorization(UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound, delegate { });
                UIApplication.SharedApplication.RegisterForRemoteNotifications();
            }
            else
            {
                UIRemoteNotificationType notificationTypes = UIRemoteNotificationType.Alert | UIRemoteNotificationType.Badge | UIRemoteNotificationType.Sound;
                UIApplication.SharedApplication.RegisterForRemoteNotifications(notificationTypes);
            }
        }

        public void RegisterDevice()
        {
            Messaging.SharedInstance.SubscribeToTopic("news");
        }
    }
}

Step 7: Use the Common Interface in Xamarin.Forms

Finally, use this common interface to interact with push notifications from your shared code.

Example Usage:

public MainPage()
{
    InitializeComponent();

    var pushNotificationService = DependencyService.Get<IPushNotification>();
    pushNotificationService.Initialize();
}

// Additional functionality can go here, such as sending a token to the server, subscribing/unsubscribing to topics

Sending a Push Notification

Go to your Firebase Console:

1. Navigate to Cloud Messaging section.
2. Click on 'Compose Message'.
3. Enter details for your push message and select either topic (iOS and Android) or user segments.
4. Choose the delivery platform(s).
5. Send the message.

Upon sending the message, all the devices registered with the specified topic or segment should receive the notification.