Update notification delegates to event args

Author: shepherd-l

com.onesignal.unity.android/Editor/OneSignalAndroidDependencies.xml

@@ -3,6 +3,6 @@
     <repositories>
       <repository>https://repo.maven.apache.org/maven2</repository>
     </repositories>
-    <androidPackage spec="com.onesignal:OneSignal:5.0.0-beta2" />
+    <androidPackage spec="com.onesignal:OneSignal:5.0.0-beta4" />
   </androidPackages>
 </dependencies>

com.onesignal.unity.core/Runtime/Notifications/Internal/NotificationClickedResult.cs renamed to com.onesignal.unity.android/Runtime/AndroidDisplayableNotification.cs

@@ -1,59 +1,40 @@
-/*
- * Modified MIT License
- *
- * Copyright 2022 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
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * 1. The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * 2. All copies of substantial portions of the Software may only be used in connection
- * with services provided by OneSignal.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-using System;
-using OneSignalSDK.Notifications.Models;
-
-namespace OneSignalSDK.Notifications.Internal {
-    /// <summary>
-    /// See full documentation at
-    /// https://documentation.onesignal.com/docs/sdk-notification-event-handlers#notification-opened-event
-    /// </summary>
-    [Serializable] public sealed class NotificationClickedResult : INotificationClickedResult {
-        /// <summary>
-        /// Action the user took on the notification
-        /// </summary>
-        public INotificationAction Action => action;
-        
-        /// <summary>
-        /// Notification the user received
-        /// </summary>
-        public INotification Notification => notification;
-
-        #region Native Field Handling
-            public NotificationAction action;
-            public Notification notification;
-        #endregion
-
-        public NotificationClickedResult() {}
-
-        public NotificationClickedResult(Notification notification, NotificationAction action) {
-            this.action = action;
-            this.notification = notification;
-        }
-    }
-}
+/*
+ * Modified MIT License
+ *
+ * Copyright 2022 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * 2. All copies of substantial portions of the Software may only be used in connection
+ * with services provided by OneSignal.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using UnityEngine;
+using OneSignalSDK.Notifications.Internal;
+using OneSignalSDK.Notifications.Models;
+
+namespace OneSignalSDK.Android.Notifications.Models {
+    public sealed class AndroidDisplayableNotification : Notification, IDisplayableNotification {
+        public AndroidJavaObject NotifJO { get; set; }
+
+        public void Display()
+            => NotifJO?.Call("display");
+    }
+}

com.onesignal.unity.core/Runtime/Notifications/Models/INotificationAction.cs.meta renamed to com.onesignal.unity.android/Runtime/AndroidDisplayableNotification.cs.meta

@@ -26,24 +26,26 @@
  */
 
 using UnityEngine;
+using System;
 using System.Threading.Tasks;
+using System.Collections.Generic;
 using OneSignalSDK.Notifications;
 using OneSignalSDK.Notifications.Models;
 using OneSignalSDK.Notifications.Internal;
 using OneSignalSDK.Android.Utilities;
-using System.Collections.Generic;
+using OneSignalSDK.Android.Notifications.Models;
 
 namespace OneSignalSDK.Android.Notifications {
     internal sealed class AndroidNotificationsManager : INotificationsManager {
         private readonly AndroidJavaObject _notifications;
-        
+
         public AndroidNotificationsManager(AndroidJavaClass sdkClass) {
             _notifications = sdkClass.CallStatic<AndroidJavaObject>("getNotifications");
         }
 
-        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;
 
         public bool Permission {
             get => _notifications.Call<bool>("getPermission");
@@ -60,69 +62,90 @@ public void ClearAllNotifications() {
         }
 
         public void Initialize() {
-            _notifications.Call("addPermissionChangedHandler", new InternalPermissionChangedHandler(this));
-            _notifications.Call("setNotificationWillShowInForegroundHandler", new InternalNotificationWillShowInForegroundHandler(this));
-            _notifications.Call("setNotificationClickHandler", new InternalNotificationClickHandler(this));
+            _notifications.Call("addPermissionObserver", new InternalPermissionObserver(this));
+            _notifications.Call("addForegroundLifecycleListener", new InternalNotificationLifecycleListener(this));
+            _notifications.Call("addClickListener", new InternalNotificationClickListener(this));
         }
 
-        private sealed class InternalPermissionChangedHandler : OneSignalAwaitableAndroidJavaProxy<bool> {
+        private sealed class InternalPermissionObserver : OneSignalAwaitableAndroidJavaProxy<bool> {
             private AndroidNotificationsManager _parent;
 
-            public InternalPermissionChangedHandler(AndroidNotificationsManager notificationsManager) : base("notifications.IPermissionChangedHandler") {
+            public InternalPermissionObserver(AndroidNotificationsManager notificationsManager) : base("notifications.IPermissionObserver") {
                 _parent = notificationsManager;
             }
 
             /// <param name="permission">boolean</param>
-            public void onPermissionChanged(bool permission) {
-                UnityMainThreadDispatch.Post(state => _parent.PermissionChanged?.Invoke(permission));
+            public void onNotificationPermissionChange(bool permission) {
+                EventHandler<NotificationPermissionChangedEventArgs> handler = _parent.PermissionChanged;
+                if (handler != null)
+                {
+                    UnityMainThreadDispatch.Post(state => handler(this, new NotificationPermissionChangedEventArgs(permission)));
+                }
             }
         }
 
-        private sealed class InternalNotificationWillShowInForegroundHandler : OneSignalAndroidJavaProxy {
+        private sealed class InternalNotificationLifecycleListener : OneSignalAndroidJavaProxy {
             private AndroidNotificationsManager _parent;
 
-            public InternalNotificationWillShowInForegroundHandler(AndroidNotificationsManager notificationsManager) : base("notifications.INotificationWillShowInForegroundHandler") {
+            public InternalNotificationLifecycleListener(AndroidNotificationsManager notificationsManager) : base("notifications.INotificationLifecycleListener") {
                 _parent = notificationsManager;
             }
 
-            /// <param name="notificationReceivedEvent">INotificationReceivedEvent</param>
-            public void notificationWillShowInForeground(AndroidJavaObject notificationReceivedEvent) {
-                var notifJO = notificationReceivedEvent.Call<AndroidJavaObject>("getNotification");
+            /// <param name="willDisplayEvent">INotificationWillDisplayEvent</param>
+            public void onWillDisplay(AndroidJavaObject willDisplayEvent) {
+                var notifJO = willDisplayEvent.Call<AndroidJavaObject>("getNotification");
+                var notification = _getNotification(notifJO);
+
+                var args = new InternalNotificationWillDisplayEventArgs(willDisplayEvent, notification);
 
-                if (_parent.WillShow == null) {
-                    notificationReceivedEvent.Call("complete", notifJO);
-                    return;
+                EventHandler<NotificationWillDisplayEventArgs> handler = _parent.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(_parent, args));
                 }
+            }
+        }
 
-                var notification = _getNotification(notifJO);
+        public class InternalNotificationWillDisplayEventArgs : NotificationWillDisplayEventArgs {
+            private AndroidJavaObject _willDisplayEvent;
 
-                UnityMainThreadDispatch.Post(state => notificationReceivedEvent.Call("complete", _parent.WillShow(notification) != null ? notifJO : null));
+            public InternalNotificationWillDisplayEventArgs(AndroidJavaObject willDisplayEvent, IDisplayableNotification notification) : base(notification) {
+                _willDisplayEvent = willDisplayEvent;
             }
+
+            public override void PreventDefault() => _willDisplayEvent.Call("preventDefault");
         }
 
-        private sealed class InternalNotificationClickHandler : OneSignalAndroidJavaProxy {
+        private sealed class InternalNotificationClickListener : OneSignalAndroidJavaProxy {
             private AndroidNotificationsManager _parent;
 
-            public InternalNotificationClickHandler(AndroidNotificationsManager notificationsManager) : base("notifications.INotificationClickHandler") {
+            public InternalNotificationClickListener(AndroidNotificationsManager notificationsManager) : base("notifications.INotificationClickListener") {
                 _parent = notificationsManager;
             }
 
-            /// <param name="result">INotificationClickResult</param>
-            public void notificationClicked(AndroidJavaObject result) {
-                var notifJO = result.Call<AndroidJavaObject>("getNotification");
+            /// <param name="clickEvent">INotificationClickEvent</param>
+            public void onClick(AndroidJavaObject clickEvent) {
+                var notifJO = clickEvent.Call<AndroidJavaObject>("getNotification");
                 var notification = _getNotification(notifJO);
 
-                var actionJO = result.Call<AndroidJavaObject>("getAction");
-                var action = _getAction(actionJO);
+                var resultJO = clickEvent.Call<AndroidJavaObject>("getResult");
+                var result = resultJO.ToSerializable<NotificationClickResult>();
 
-                var notifClickResult = new NotificationClickedResult(notification, action);
+                NotificationClickEventArgs args = new NotificationClickEventArgs(notification, result);
 
-                UnityMainThreadDispatch.Post(state => _parent.Clicked?.Invoke(notifClickResult));
+                EventHandler<NotificationClickEventArgs> handler = _parent.Clicked;
+                if (handler != null)
+                {
+                    UnityMainThreadDispatch.Post(state => handler(this, args));
+                }
             }
         }
 
-        private static Notification _getNotification(AndroidJavaObject notifJO) {
-            var notification = notifJO.ToSerializable<Notification>();
+        private static AndroidDisplayableNotification _getNotification(AndroidJavaObject notifJO) {
+            var notification = notifJO.ToSerializable<AndroidDisplayableNotification>();
 
             var dataJson = notifJO.Call<AndroidJavaObject>("getAdditionalData");
             if (dataJson != null) {
@@ -142,14 +165,10 @@ private static Notification _getNotification(AndroidJavaObject notifJO) {
                 notification.rawPayload = rawPayloadJsonStr;
             }
 
-            return notification;
-        }
-
-        private static NotificationAction _getAction(AndroidJavaObject actionJO) {
-            var action = actionJO.ToSerializable<NotificationAction>();
-            action.type = (ActionType) actionJO.Call<AndroidJavaObject>("getType").Call<int>("ordinal");
+            // attach the Java-Object to the notifification just built.
+            notification.NotifJO = notifJO;
 
-            return action;
+            return notification;
         }
     }
 }

com.onesignal.unity.android/Runtime/AndroidNotificationsManager.cs

@@ -25,31 +25,55 @@
  * THE SOFTWARE.
  */
 
+using System;
 using System.Threading.Tasks;
 using OneSignalSDK.Notifications.Models;
 
 namespace OneSignalSDK.Notifications {
     /// <summary>
     /// When a push notification has been received and is about to be displayed
     /// </summary>
-    /// <param name="notification">Details of the notification to be shown</param>
-    /// <returns>The notification object or null if the notification should not be displayed</returns>
-    public delegate INotification NotificationWillShowDelegate(INotification notification);
+    public class NotificationWillDisplayEventArgs : EventArgs
+    {
+        public IDisplayableNotification Notification { get; }
+
+        public NotificationWillDisplayEventArgs(IDisplayableNotification notification) {
+            Notification = notification;
+        }
+
+        /// <summary>
+        /// Prevents OneSignal from displaying the notification automatically.
+        /// </summary>
+        public virtual void PreventDefault() {
+
+        }
+    }
 
     /// <summary>
     /// When a push notification was acted on by the user.
     /// </summary>
-    /// <param name="result">The Notification clicked result describing:
-    ///     1. The notification opened
-    ///     2. The action taken by the user.
-    /// </param>
-    public delegate void NotificationClickedDelegate(INotificationClickedResult result);
+    public class NotificationClickEventArgs : EventArgs
+    {
+        public INotification Notification { get; }
+        public INotificationClickResult Result { get; }
+
+        public NotificationClickEventArgs(INotification notification, INotificationClickResult result) {
+            Notification = notification;
+            Result = result;
+        }
+    }
 
     /// <summary>
     /// When the user enables or disables notifications for your app from the system settings outside of your app. 
     /// </summary>
-    /// <param name="permission">Boolean value for authorization of push notifications</param>
-    public delegate void PermissionChangedDelegate(bool permission);
+    public class NotificationPermissionChangedEventArgs : EventArgs
+    {
+        public bool Permission { get; }
+
+        public NotificationPermissionChangedEventArgs(bool permission) {
+            Permission = permission;
+        }
+    }
 
     /// <summary>
     /// The entry point to the notification SDK for OneSignal.
@@ -58,17 +82,17 @@ public interface INotificationsManager {
         /// <summary>
         /// When a push notification has been received while app is in the foreground
         /// </summary>
-        event NotificationWillShowDelegate WillShow;
+        event EventHandler<NotificationWillDisplayEventArgs> ForegroundWillDisplay;
 
         /// <summary>
         /// When a push notification has been clicked by the user
         /// </summary>
-        event NotificationClickedDelegate Clicked;
+        event EventHandler<NotificationClickEventArgs> Clicked;
 
         /// <summary>
         /// When this device's permissions for authorization of push notifications have changed.
         /// </summary>
-        event PermissionChangedDelegate PermissionChanged;
+        event EventHandler<NotificationPermissionChangedEventArgs> PermissionChanged;
 
         /// <summary>
         /// Current status of permissions granted by this device for push notifications

com.onesignal.unity.core/Runtime/Notifications/INotificationsManager.cs

@@ -301,7 +301,7 @@ namespace OneSignalSDK.Notifications.Internal {
         #endregion
     }
 
-    [Serializable] public sealed class Notification : NotificationBase, INotification {
+    [Serializable] public class Notification : NotificationBase, INotification {
         /// <summary>
         /// Gets the notification payloads a summary notification was created from
         /// </summary>