feat: [SDK-4788] add iOS manual notification forwarding

OneSignalSDK.DotNet.iOS.Binding/ApiDefinitions.cs

@@ -8,6 +8,15 @@
 
 namespace Com.OneSignal.iOS
 {
+    [Internal]
+    [BaseType(typeof(NSObject))]
+    interface OneSignalCoreHelper
+    {
+        [Static]
+        [Export("isOneSignalPayload:")]
+        bool IsOneSignalPayload(NSDictionary payload);
+    }
+
     // @interface OSNotification : NSObject
     [BaseType(typeof(NSObject))]
     interface OSNotification
@@ -344,6 +353,30 @@ [NullAllowed] OSNotificationLifecycleListener listener
         //[Static, Abstract]
         [Export("clearAll")]
         void ClearAll();
+
+        [Export("didRegisterForRemoteNotificationsWithDeviceToken:")]
+        void DidRegisterForRemoteNotifications(NSData deviceToken);
+
+        [Export("didFailToRegisterForRemoteNotificationsWithError:")]
+        void DidFailToRegisterForRemoteNotifications(NSError error);
+
+        [Export("didReceiveRemoteNotification:completionHandler:")]
+        void DidReceiveRemoteNotification(
+            NSDictionary userInfo,
+            Action<UIBackgroundFetchResult> completionHandler
+        );
+
+        [Export("willPresentNotificationWithPayload:completion:")]
+        void WillPresentNotification(
+            NSDictionary payload,
+            OSNotificationDisplayResponse completion
+        );
+
+        [Export("didReceiveNotificationResponse:")]
+        void DidReceiveNotificationResponse(UNNotificationResponse response);
+
+        [Export("setBadgeCount:")]
+        void SetBadgeCount(nint badgeCount);
     }
 
     // @interface OSPushSubscriptionChangedState : NSObject

OneSignalSDK.DotNet.iOS.Binding/OneSignalSDK.DotNet.iOS.Binding.csproj

@@ -37,6 +37,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Folder Include="Resources\" />
+    <InternalsVisibleTo Include="OneSignalSDK.DotNet.iOS" />
   </ItemGroup>
   <ItemGroup>
     <ObjcBindingCoreSource Include="StructsAndEnums.cs" />

OneSignalSDK.DotNet.iOS/NotificationsManualIntegration.cs

@@ -0,0 +1,141 @@
+using Foundation;
+using UIKit;
+using UserNotifications;
+using OneSignalNative = Com.OneSignal.iOS.OneSignal;
+
+namespace OneSignalSDK.DotNet.iOS;
+
+/// <summary>
+/// Supported iOS notification callbacks for apps that disable OneSignal method swizzling.
+/// </summary>
+public static class NotificationsManualIntegration
+{
+    private const string DisableSwizzlingKey = "OneSignal_disable_swizzling";
+
+    /// <summary>
+    /// Returns whether manual notification forwarding is enabled in the app's Info.plist.
+    /// </summary>
+    public static bool IsEnabled =>
+        (NSBundle.MainBundle.ObjectForInfoDictionary(DisableSwizzlingKey) as NSNumber)?.BoolValue
+        ?? false;
+
+    /// <summary>
+    /// Returns whether a notification payload belongs to OneSignal.
+    /// </summary>
+    public static bool IsOneSignalNotification(NSDictionary payload)
+    {
+        ArgumentNullException.ThrowIfNull(payload);
+        return Com.OneSignal.iOS.OneSignalCoreHelper.IsOneSignalPayload(payload);
+    }
+
+    /// <summary>
+    /// Forwards successful APNs registration to OneSignal.
+    /// </summary>
+    public static void DidRegisterForRemoteNotifications(NSData deviceToken)
+    {
+        EnsureEnabled();
+        ArgumentNullException.ThrowIfNull(deviceToken);
+        OneSignalNative.Notifications.DidRegisterForRemoteNotifications(deviceToken);
+    }
+
+    /// <summary>
+    /// Forwards failed APNs registration to OneSignal.
+    /// </summary>
+    public static void DidFailToRegisterForRemoteNotifications(NSError error)
+    {
+        EnsureEnabled();
+        ArgumentNullException.ThrowIfNull(error);
+        OneSignalNative.Notifications.DidFailToRegisterForRemoteNotifications(error);
+    }
+
+    /// <summary>
+    /// Forwards a background remote notification to OneSignal. OneSignal owns the completion handler.
+    /// </summary>
+    public static void DidReceiveRemoteNotification(
+        NSDictionary userInfo,
+        Action<UIBackgroundFetchResult> completionHandler
+    )
+    {
+        EnsureEnabled();
+        ArgumentNullException.ThrowIfNull(userInfo);
+        ArgumentNullException.ThrowIfNull(completionHandler);
+        OneSignalNative.Notifications.DidReceiveRemoteNotification(userInfo, completionHandler);
+    }
+
+    /// <summary>
+    /// Handles a OneSignal foreground notification and completes Apple's callback exactly once.
+    /// </summary>
+    /// <returns><see langword="true"/> when the notification belonged to OneSignal.</returns>
+    public static bool TryHandleWillPresentNotification(
+        UNNotification notification,
+        UNNotificationPresentationOptions presentationOptions,
+        Action<UNNotificationPresentationOptions> completionHandler
+    )
+    {
+        EnsureEnabled();
+        ArgumentNullException.ThrowIfNull(notification);
+        ArgumentNullException.ThrowIfNull(completionHandler);
+
+        var payload = notification.Request.Content.UserInfo;
+        if (!IsOneSignalNotification(payload))
+            return false;
+
+        OneSignalNative.Notifications.WillPresentNotification(
+            payload,
+            displayableNotification =>
+                completionHandler(
+                    displayableNotification == null
+                        ? (UNNotificationPresentationOptions)0
+                        : presentationOptions
+                )
+        );
+        return true;
+    }
+
+    /// <summary>
+    /// Handles a OneSignal notification response and completes Apple's callback exactly once.
+    /// </summary>
+    /// <returns><see langword="true"/> when the notification belonged to OneSignal.</returns>
+    public static bool TryHandleNotificationResponse(
+        UNNotificationResponse response,
+        Action completionHandler
+    )
+    {
+        EnsureEnabled();
+        ArgumentNullException.ThrowIfNull(response);
+        ArgumentNullException.ThrowIfNull(completionHandler);
+
+        if (!IsOneSignalNotification(response.Notification.Request.Content.UserInfo))
+            return false;
+
+        try
+        {
+            OneSignalNative.Notifications.DidReceiveNotificationResponse(response);
+        }
+        finally
+        {
+            completionHandler();
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Sets the app icon badge count through OneSignal.
+    /// </summary>
+    public static void SetBadgeCount(nint badgeCount)
+    {
+        EnsureEnabled();
+        OneSignalNative.Notifications.SetBadgeCount(badgeCount);
+    }
+
+    private static void EnsureEnabled()
+    {
+        if (!IsEnabled)
+        {
+            throw new InvalidOperationException(
+                $"Set {DisableSwizzlingKey} to true in Info.plist before using manual integration."
+            );
+        }
+    }
+}

examples/plugin-local-notif/.env.example

@@ -1,2 +1 @@
-# Default App ID (used when ONESIGNAL_APP_ID is empty or missing): 77e32082-ea27-42e3-a898-c72e141824ef
 ONESIGNAL_APP_ID=your-onesignal-app-id

examples/plugin-local-notif/DotEnv.cs

@@ -2,9 +2,14 @@ namespace PluginLocalNotifDemo;
 
 public static class DotEnv
 {
+    private const string OneSignalAppIdPlaceholder = "your-onesignal-app-id";
     private static readonly Dictionary<string, string> Values = new();
     private static bool _loaded;
 
+    public static string OneSignalAppId => Get("ONESIGNAL_APP_ID").Trim();
+    public static bool HasOneSignalAppId =>
+        !string.IsNullOrWhiteSpace(OneSignalAppId) && OneSignalAppId != OneSignalAppIdPlaceholder;
+
     public static void Load()
     {
         if (_loaded)

examples/plugin-local-notif/MainPage.cs

@@ -1,3 +1,5 @@
+using System.Text;
+using System.Text.Json;
 using OneSignalSDK.DotNet;
 using OneSignalSDK.DotNet.Core.Notifications;
 using OneSignalSDK.DotNet.Core.User;
@@ -88,6 +90,24 @@ public MainPage()
             );
         };
 
+        var showOneSignalNotificationButton = new Button
+        {
+            Text = "Show OneSignal Notification",
+            AutomationId = "show_onesignal_notification_button",
+        };
+        showOneSignalNotificationButton.Clicked += async (s, e) =>
+        {
+            showOneSignalNotificationButton.IsEnabled = false;
+            try
+            {
+                await SendSimpleOneSignalNotificationAsync();
+            }
+            finally
+            {
+                showOneSignalNotificationButton.IsEnabled = true;
+            }
+        };
+
         var clearButton = new Button
         {
             Text = "Clear Delivered Notifications",
@@ -133,6 +153,7 @@ public MainPage()
                     requestOneSignalPermissionButton,
                     requestLocalPermissionButton,
                     showLocalNotificationButton,
+                    showOneSignalNotificationButton,
                     clearButton,
                     refreshPushInfoButton,
                     _statusLabel,
@@ -160,10 +181,9 @@ private void RefreshPushInfoLabel()
     {
         var pushSubscription = OneSignal.User.PushSubscription;
         _pushInfoLabel.Text =
-            $"OneSignal ID: {FormatValue(OneSignal.User.OneSignalId)}\n"
-            + $"Push subscription ID: {FormatValue(pushSubscription.Id)}\n"
-            + $"Push opted in: {pushSubscription.OptedIn}\n"
-            + $"Push token: {FormatValue(pushSubscription.Token)}";
+            $"OneSignal ID:\n{FormatValue(OneSignal.User.OneSignalId)}\n"
+            + $"Push subscription ID:\n{FormatValue(pushSubscription.Id)}\n"
+            + $"Push opted in: {pushSubscription.OptedIn}";
     }
 
     private void OnPermissionChanged(object? sender, NotificationPermissionChangedEventArgs args)
@@ -185,6 +205,51 @@ private void OnUserChanged(object? sender, UserStateChangedEventArgs args)
         MainThread.BeginInvokeOnMainThread(RefreshPushInfoLabel);
     }
 
+    private async Task SendSimpleOneSignalNotificationAsync()
+    {
+        if (!DotEnv.HasOneSignalAppId)
+        {
+            SetStatus("Set ONESIGNAL_APP_ID in .env before sending a OneSignal notification.");
+            return;
+        }
+
+        var pushSubscriptionId = OneSignal.User.PushSubscription.Id;
+        if (string.IsNullOrWhiteSpace(pushSubscriptionId))
+        {
+            SetStatus(
+                "No OneSignal push subscription ID yet. Refresh after permission is granted."
+            );
+            return;
+        }
+
+        using var client = new HttpClient();
+        client.DefaultRequestHeaders.Add("Accept", "application/vnd.onesignal.v1+json");
+
+        var payload = new Dictionary<string, object>
+        {
+            ["app_id"] = DotEnv.OneSignalAppId,
+            ["headings"] = new Dictionary<string, string> { ["en"] = "Simple Notification" },
+            ["contents"] = new Dictionary<string, string>
+            {
+                ["en"] = "This is a simple push notification",
+            },
+            ["include_subscription_ids"] = new[] { pushSubscriptionId },
+        };
+
+        var json = JsonSerializer.Serialize(payload);
+        var response = await client.PostAsync(
+            "https://onesignal.com/api/v1/notifications",
+            new StringContent(json, Encoding.UTF8, "application/json")
+        );
+        var responseJson = await response.Content.ReadAsStringAsync();
+
+        SetStatus(
+            response.IsSuccessStatusCode
+                ? $"OneSignal notification requested: {responseJson}"
+                : $"OneSignal notification failed: {responseJson}"
+        );
+    }
+
     private void SetStatus(string message)
     {
         MainThread.BeginInvokeOnMainThread(() =>