com.onesignal.unity.ios 5.0.0-beta.2 → 5.0.0

package/Runtime/iOSNotificationsManager.cs

@@ -1,7 +1,7 @@
 /*
  * Modified MIT License
  *
- * Copyright 2022 OneSignal
+ * Copyright 2023 OneSignal
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -32,28 +32,30 @@ using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using OneSignalSDK.Notifications;
 using OneSignalSDK.Notifications.Models;
+using OneSignalSDK.Notifications.Internal;
 using OneSignalSDK.iOS.Utilities;
+using OneSignalSDK.iOS.Notifications.Models;
 
 namespace OneSignalSDK.iOS.Notifications {
     internal sealed class iOSNotificationsManager : INotificationsManager {
         [DllImport("__Internal")] private static extern bool _notificationsGetPermission();
-        //[DllImport("__Internal")] private static extern bool _notificationsGetCanRequestPermission(); // iOS only for now
+        [DllImport("__Internal")] private static extern bool _notificationsGetCanRequestPermission();
+        [DllImport("__Internal")] private static extern int _notificationsGetPermissionNative();
         [DllImport("__Internal")] private static extern void _notificationsRequestPermission(bool fallbackToSettings, int hashCode, BooleanResponseDelegate callback);
         [DllImport("__Internal")] private static extern void _notificationsClearAll();
-        //[DllImport("__Internal")] private static extern void _registerForProvisionalAuthorization(); // iOS only
-        [DllImport("__Internal")] private static extern void _notificationsAddPermissionStateChangedCallback(StateListenerDelegate callback);
-        [DllImport("__Internal")] private static extern void _notificationsSetWillShowHandler(NotificationWillShowInForegroundDelegate callback);
-        [DllImport("__Internal")] private static extern void _notificationsSetOpenedHandler(StringListenerDelegate callback);
-
-        public delegate void StateListenerDelegate(string current);
-
-        private delegate bool NotificationWillShowInForegroundDelegate(string notification);
-        private delegate void StringListenerDelegate(string response);
+        [DllImport("__Internal")] private static extern void _notificationsAddPermissionObserver(PermissionListenerDelegate callback);
+        [DllImport("__Internal")] private static extern void _notificationsSetForegroundWillDisplayCallback(WillDisplayListenerDelegate callback);
+        [DllImport("__Internal")] private static extern void _notificationsWillDisplayEventPreventDefault(string notificationId);
+        [DllImport("__Internal")] private static extern void _notificationsSetClickCallback(ClickListenerDelegate callback);
+
+        public delegate void PermissionListenerDelegate(bool permission);
+        private delegate void WillDisplayListenerDelegate(string notification);
+        private delegate void ClickListenerDelegate(string notification, string resultActionId, string resultUrl);
         private delegate void BooleanResponseDelegate(int hashCode, bool response);
 
-        public event NotificationWillShowDelegate WillShow;
-        public event NotificationClickedDelegate Clicked;
-        public event PermissionChangedDelegate PermissionChanged;
+        public event EventHandler<NotificationWillDisplayEventArgs> ForegroundWillDisplay;
+        public event EventHandler<NotificationClickEventArgs> Clicked;
+        public event EventHandler<NotificationPermissionChangedEventArgs> PermissionChanged;
 
         private static iOSNotificationsManager _instance;
 
@@ -65,6 +67,14 @@ namespace OneSignalSDK.iOS.Notifications {
             get => _notificationsGetPermission();
         }
 
+        public bool CanRequestPermission {
+            get => _notificationsGetCanRequestPermission();
+        }
+
+        public NotificationPermission PermissionNative {
+            get => (NotificationPermission)_notificationsGetPermissionNative();
+        }
+
         public async Task<bool> RequestPermissionAsync(bool fallbackToSettings) {
             var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
             _notificationsRequestPermission(fallbackToSettings, hashCode, BooleanCallbackProxy);
@@ -76,57 +86,76 @@ namespace OneSignalSDK.iOS.Notifications {
         }
 
         public void Initialize() {
-            _notificationsAddPermissionStateChangedCallback(_onPermissionStateChanged);
-            _notificationsSetWillShowHandler(_onWillShow);
-            _notificationsSetOpenedHandler(_onOpened);
+            _notificationsAddPermissionObserver(_onPermissionStateChanged);
+            _notificationsSetForegroundWillDisplayCallback(_onForegroundWillDisplay);
+            _notificationsSetClickCallback(_onClicked);
         }
 
-        [AOT.MonoPInvokeCallback(typeof(StateListenerDelegate))]
-        private static void _onPermissionStateChanged(string current) {
-            var curr = JsonUtility.FromJson<PermissionState>(current);
-            UnityMainThreadDispatch.Post(state => _instance.PermissionChanged?.Invoke(curr.permission));
+        [AOT.MonoPInvokeCallback(typeof(PermissionListenerDelegate))]
+        private static void _onPermissionStateChanged(bool permission) {
+            NotificationPermissionChangedEventArgs args = new NotificationPermissionChangedEventArgs(permission);
+
+            EventHandler<NotificationPermissionChangedEventArgs> handler = _instance.PermissionChanged;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
         }
 
-        /// <param name="response">OSNotification</param>
-        [AOT.MonoPInvokeCallback(typeof(NotificationWillShowInForegroundDelegate))]
-        private static bool _onWillShow(string response) {
-            if (_instance.WillShow == null)
-                return true;
+        [AOT.MonoPInvokeCallback(typeof(WillDisplayListenerDelegate))]
+        private static void _onForegroundWillDisplay(string notification) {
+            var notif = JsonUtility.FromJson<iOSDisplayableNotification>(notification);
+            _fillNotifFromObj(ref notif, Json.Deserialize(notification));
+
+            InternalNotificationWillDisplayEventArgs args = new InternalNotificationWillDisplayEventArgs(notif);
 
-            var notification = JsonUtility.FromJson<Notification>(response);
-            _fillNotifFromObj(ref notification, Json.Deserialize(response));
+            EventHandler<NotificationWillDisplayEventArgs> handler = _instance.ForegroundWillDisplay;
+            if (handler != null)
+            {
+                // We use Send instead of Post because we need to *not* return to our caller until the
+                // event handlers have returned themselves. This allows a handler to call PreventDefault()
+                // which will get passed down to Android in InternalNotificationWillDisplayEventArgs.
+                UnityMainThreadDispatch.Send(state => handler(_instance, args));
+            }
+        }
 
-            Notification resultNotif = null;
-            // Blocks current thread using Send to wait for value to assign to resultNotif inorder to display
-            UnityMainThreadDispatch.Send(state => { resultNotif = _instance.WillShow(notification);});
+        public class InternalNotificationWillDisplayEventArgs : NotificationWillDisplayEventArgs {
+            public InternalNotificationWillDisplayEventArgs(IDisplayableNotification notification) : base(notification) { }
 
-            return resultNotif != null;
+            public override void PreventDefault() {
+                _notificationsWillDisplayEventPreventDefault(this.Notification.NotificationId);
+            }
         }
 
-        /// <param name="response">OSNotificationOpenedResult</param>
-        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
-        private static void _onOpened(string response) {
-            var notifOpenResult = JsonUtility.FromJson<NotificationClickedResult>(response);
+        [AOT.MonoPInvokeCallback(typeof(ClickListenerDelegate))]
+        private static void _onClicked(string notification, string resultActionId, string resultUrl) {
+            var notif = JsonUtility.FromJson<iOSDisplayableNotification>(notification);
+            _fillNotifFromObj(ref notif, Json.Deserialize(notification));
+
+            var result = new NotificationClickResult(resultActionId, resultUrl);
+
+            NotificationClickEventArgs args = new NotificationClickEventArgs(notif, result);
 
-            if (Json.Deserialize(response) is Dictionary<string, object> resultDict && resultDict.ContainsKey("notification"))
-                _fillNotifFromObj(ref notifOpenResult.notification, resultDict["notification"]);
+            EventHandler<NotificationClickEventArgs> handler = _instance.Clicked;
+            if (handler != null)
+            {
+                if (OneSignalPlatform.DidInitialize)
+                    UnityMainThreadDispatch.Post(state => handler(_instance, args));
+                else {
+                    void invokeOpened(string appId) {
+                        OneSignalPlatform.OnInitialize -= invokeOpened;
+                        UnityMainThreadDispatch.Post(state => handler(_instance, args));
+                    }
 
-            if (OneSignal.DidInitialize)
-                UnityMainThreadDispatch.Post(state => _instance.Clicked?.Invoke(notifOpenResult));
-            else {
-                void invokeOpened(string appId) {
-                    OneSignal.OnInitialize -= invokeOpened;
-                    UnityMainThreadDispatch.Post(state => _instance.Clicked?.Invoke(notifOpenResult));
+                    OneSignalPlatform.OnInitialize += invokeOpened; 
                 }
-                
-                OneSignal.OnInitialize += invokeOpened; 
             }
         }
 
-        private static void _fillNotifFromObj(ref Notification notif, object notifObj) {
+        private static void _fillNotifFromObj(ref iOSDisplayableNotification notif, object notifObj) {
             if (!(notifObj is Dictionary<string, object> notifDict)) 
                 return;
-            
+
             if (notifDict.ContainsKey("additionalData"))
                 notif.additionalData = notifDict["additionalData"] as Dictionary<string, object>;
             
@@ -137,10 +166,6 @@ namespace OneSignalSDK.iOS.Notifications {
                 notif.rawPayload = Json.Serialize(payloadDict);
         }
 
-        [Serializable] private sealed class PermissionState { // temp
-            public bool permission;
-        }
-
         [AOT.MonoPInvokeCallback(typeof(BooleanResponseDelegate))]
         private static void BooleanCallbackProxy(int hashCode, bool response)
             => WaitingProxy.ResolveCallbackProxy(hashCode, response);

package/Runtime/iOSPushSubscription.cs

@@ -1,7 +1,7 @@
 /*
  * Modified MIT License
  *
- * Copyright 2022 OneSignal
+ * Copyright 2023 OneSignal
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,6 +29,9 @@ using System;
 using UnityEngine;
 using System.Runtime.InteropServices;
 using OneSignalSDK.User.Models;
+using OneSignalSDK.User.Internal;
+
+using OneSignalSDK.Debug.Utilities;
 
 namespace OneSignalSDK.iOS.User.Models {
     internal sealed class iOSPushSubscription : IPushSubscription {
@@ -41,7 +44,7 @@ namespace OneSignalSDK.iOS.User.Models {
 
         public delegate void StateListenerDelegate(string current, string previous);
 
-        public event SubscriptionChangedDelegate Changed;
+        public event EventHandler<PushSubscriptionChangedEventArgs> Changed;
 
         private static iOSPushSubscription _instance;
 
@@ -74,8 +77,16 @@ namespace OneSignalSDK.iOS.User.Models {
         [AOT.MonoPInvokeCallback(typeof(StateListenerDelegate))]
         private static void _onPushSubscriptionStateChanged(string current, string previous) {
             var curr = JsonUtility.FromJson<PushSubscriptionState>(current);
-            //var prev = JsonUtility.FromJson<PushSubscriptionState>(previous);
-            UnityMainThreadDispatch.Post(state => _instance.Changed?.Invoke(curr));
+            var prev = JsonUtility.FromJson<PushSubscriptionState>(previous);
+
+            PushSubscriptionChangedState state = new PushSubscriptionChangedState(prev, curr);
+            PushSubscriptionChangedEventArgs args = new PushSubscriptionChangedEventArgs(state);
+
+            EventHandler<PushSubscriptionChangedEventArgs> handler = _instance.Changed;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
         }
     }
 }

package/Runtime/iOSSessionManager.cs

@@ -1,7 +1,7 @@
 /*
  * Modified MIT License
  *
- * Copyright 2022 OneSignal
+ * Copyright 2023 OneSignal
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

package/Runtime/iOSUserManager.cs

@@ -1,7 +1,7 @@
 /*
  * Modified MIT License
  *
- * Copyright 2022 OneSignal
+ * Copyright 2023 OneSignal
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.onesignal.unity.ios",
   "displayName": "OneSignal Unity SDK - iOS",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0",
   "unity": "2018.4",
   "description": "OneSignal is the market leader in customer engagement, powering mobile push, web push, email, and in-app messages.",
   "dependencies": {
-    "com.onesignal.unity.core": "5.0.0-beta.2"
+    "com.onesignal.unity.core": "5.0.0"
   },
   "keywords": [
     "push-notifications",