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

package/Editor/OneSignaliOSDependencies.xml

@@ -1,5 +1,5 @@
 <dependencies>
     <iosPods>
-            <iosPod name="OneSignalXCFramework" version="5.0.0-beta-02" addToAllTargets="true" />
+            <iosPod name="OneSignalXCFramework" version="5.0.0-beta-04" addToAllTargets="true" />
     </iosPods>
 </dependencies>

package/Runtime/OneSignaliOS.cs

@@ -25,18 +25,11 @@
  * THE SOFTWARE.
  */
 
-using System.Collections.Generic;
+using UnityEngine;
 using System.Linq;
 using System.Threading.Tasks;
-using UnityEngine;
+using System.Collections.Generic;
 using System.Runtime.InteropServices;
-using OneSignalSDK.iOS.Notifications;
-using OneSignalSDK.iOS.InAppMessages;
-using OneSignalSDK.iOS.Debug;
-using OneSignalSDK.iOS.Location;
-using OneSignalSDK.iOS.Session;
-using OneSignalSDK.iOS.User;
-using OneSignalSDK.iOS.Utilities;
 using OneSignalSDK.Notifications;
 using OneSignalSDK.InAppMessages;
 using OneSignalSDK.Debug;
@@ -44,22 +37,24 @@ using OneSignalSDK.Debug.Utilities;
 using OneSignalSDK.Location;
 using OneSignalSDK.Session;
 using OneSignalSDK.User;
+using OneSignalSDK.LiveActivities;
+using OneSignalSDK.iOS.Notifications;
+using OneSignalSDK.iOS.InAppMessages;
+using OneSignalSDK.iOS.Debug;
+using OneSignalSDK.iOS.Location;
+using OneSignalSDK.iOS.Session;
+using OneSignalSDK.iOS.User;
+using OneSignalSDK.iOS.LiveActivities;
 
 namespace OneSignalSDK.iOS {
-    public sealed partial class OneSignaliOS : OneSignal {
-        [DllImport("__Internal")] private static extern bool _getPrivacyConsent();
-        [DllImport("__Internal")] private static extern void _setPrivacyConsent(bool consent);
-        [DllImport("__Internal")] private static extern bool _getRequiresPrivacyConsent();
-        [DllImport("__Internal")] private static extern void _setRequiresPrivacyConsent(bool required);
+    public sealed partial class OneSignaliOS : OneSignalPlatform {
+        [DllImport("__Internal")] private static extern void _setConsentGiven(bool consent);
+        [DllImport("__Internal")] private static extern void _setConsentRequired(bool required);
         [DllImport("__Internal")] private static extern void _setLaunchURLsInApp(bool launchInApp);
         [DllImport("__Internal")] private static extern void _initialize(string appId);
         [DllImport("__Internal")] private static extern void _login(string externalId);
         [DllImport("__Internal")] private static extern void _loginWithJwtBearerToken(string externalId, string jwtBearerToken);
         [DllImport("__Internal")] private static extern void _logout();
-        [DllImport("__Internal")] private static extern void _enterLiveActivity(string activityId, string token, int hashCode, BooleanResponseDelegate callback);
-        [DllImport("__Internal")] private static extern void _exitLiveActivity(string activityId, int hashCode, BooleanResponseDelegate callback);
-
-        private delegate void BooleanResponseDelegate(int hashCode, bool response);
 
         private iOSUserManager _user;
         private iOSSessionManager _session;
@@ -67,6 +62,7 @@ namespace OneSignalSDK.iOS {
         private iOSLocationManager _location;
         private iOSInAppMessagesManager _inAppMessages;
         private iOSDebugManager _debug;
+        private iOSLiveActivitiesManager _liveActivities;
 
         private static OneSignaliOS _instance;
 
@@ -105,14 +101,16 @@ namespace OneSignalSDK.iOS {
             get => _debug;
         }
 
-        public override bool PrivacyConsent {
-            get => _getPrivacyConsent();
-            set => _setPrivacyConsent(value);
+        public override ILiveActivitiesManager LiveActivities {
+            get => _liveActivities;
         }
 
-        public override bool RequiresPrivacyConsent {
-            get => _getRequiresPrivacyConsent();
-            set => _setRequiresPrivacyConsent(value);
+        public override bool ConsentGiven {
+            set => _setConsentGiven(value);
+        }
+
+        public override bool ConsentRequired {
+            set => _setConsentRequired(value);
         }
 
         public override void SetLaunchURLsInApp(bool launchInApp)
@@ -144,6 +142,10 @@ namespace OneSignalSDK.iOS {
                 _session = new iOSSessionManager();
             }
 
+            if (_liveActivities == null) {
+                _liveActivities = new iOSLiveActivitiesManager();
+            }
+
             _completedInit(appId);
         }
 
@@ -158,21 +160,5 @@ namespace OneSignalSDK.iOS {
         public override void Logout() {
             _logout();
         }
-
-        public override async Task<bool> EnterLiveActivity(string activityId, string token) {
-            var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
-            _enterLiveActivity(activityId, token, hashCode, BooleanCallbackProxy);
-            return await proxy;
-        }
-
-        public override async Task<bool> ExitLiveActivity(string activityId) {
-            var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
-            _exitLiveActivity(activityId, hashCode, BooleanCallbackProxy);
-            return await proxy;
-        }
-
-        [AOT.MonoPInvokeCallback(typeof(BooleanResponseDelegate))]
-        private static void BooleanCallbackProxy(int hashCode, bool response)
-            => WaitingProxy.ResolveCallbackProxy(hashCode, response);
     }
 }

package/Runtime/OneSignaliOSInit.cs

@@ -34,7 +34,7 @@ namespace OneSignalSDK.iOS {
     /// </summary>
     internal static class OneSignaliOSInit {
         [RuntimeInitializeOnLoadMethod] public static void Init() {
-            if (!OneSignal.DidInitialize) 
+            if (!OneSignalPlatform.DidInitialize)
                 OneSignal.Default = new OneSignaliOS();
         }
     }

package/Runtime/Plugins/iOS/OneSignalBridgeUtil.h

@@ -27,9 +27,10 @@
 
 #import <UIKit/UIKit.h>
 
-@interface OneSignalBridgeUtil
+@interface OneSignalBridgeUtil : NSObject
 
 const char* jsonStringFromDictionary(NSDictionary *dictionary);
-// TObj objFromJsonString(const char* jsonString);
+NSDictionary* dictionaryFromJsonString(const char* jsonString);
+NSArray* arrayFromJsonString(const char* jsonString);
 
 @end

package/Runtime/Plugins/iOS/OneSignalBridgeUtil.mm

@@ -28,6 +28,7 @@
 #import "OneSignalBridgeUtil.h"
 
 @implementation OneSignalBridgeUtil
+
 const char* jsonStringFromDictionary(NSDictionary *dictionary) {
     NSError *error;
     NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:&error];
@@ -35,15 +36,24 @@ const char* jsonStringFromDictionary(NSDictionary *dictionary) {
     return [jsonString UTF8String];
 }
 
-// template <typename TObj>
-// TObj objFromJsonString(const char* jsonString) {
-//     NSData* jsonData = [[NSString stringWithUTF8String:jsonString] dataUsingEncoding:NSUTF8StringEncoding];
-//     NSError* error = nil;
-//     TObj arr = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
+template <typename TObj>
+TObj objFromJsonString(const char* jsonString) {
+    NSData* jsonData = [[NSString stringWithUTF8String:jsonString] dataUsingEncoding:NSUTF8StringEncoding];
+    NSError* error = nil;
+    TObj arr = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
+
+    if (error != nil)
+        return nil;
+
+    return arr;
+}
 
-//     if (error != nil)
-//         return nil;
+NSDictionary* dictionaryFromJsonString(const char* jsonString) {
+    return objFromJsonString<NSDictionary*>(jsonString);
+}
+
+NSArray* arrayFromJsonString(const char* jsonString) {
+    return objFromJsonString<NSArray*>(jsonString);
+}
 
-//     return arr;
-// }
 @end

package/Runtime/Plugins/iOS/OneSignalUnityBridge.mm

@@ -29,8 +29,6 @@
 #import <OneSignalUser/OneSignalUser-Swift.h>
 #import <OneSignalFramework/OneSignalFramework.h>
 
-typedef void (*BooleanResponseDelegate)(int hashCode, bool response);
-
 /*
  * Helpers
  */
@@ -59,36 +57,15 @@ extern "C" {
         [OneSignal logout];
     }
 
-    bool _getPrivacyConsent() {
-        return OneSignal.getPrivacyConsent;
-    }
-
-    void _setPrivacyConsent(bool consent) {
-        [OneSignal setPrivacyConsent:consent];
-    }
-
-    bool _getRequiresPrivacyConsent() {
-        return [OneSignal requiresPrivacyConsent];
+    void _setConsentGiven(bool consent) {
+        [OneSignal setConsentGiven:consent];
     }
 
-    void _setRequiresPrivacyConsent(bool required) {
-        [OneSignal setRequiresPrivacyConsent:required];
+    void _setConsentRequired(bool required) {
+        [OneSignal setConsentRequired:required];
     }
 
     void _setLaunchURLsInApp(bool launchInApp) {
         [OneSignal setLaunchURLsInApp:launchInApp];
     }
-
-    void _enterLiveActivity(const char* activityId, const char* token, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal enterLiveActivity:TO_NSSTRING(activityId)
-                        withToken:TO_NSSTRING(token)
-                        withSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                        withFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
-
-    void _exitLiveActivity(const char* activityId, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal exitLiveActivity:TO_NSSTRING(activityId)
-                        withSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                        withFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
 }

package/Runtime/Plugins/iOS/OneSignalUnityBridgeInAppMessages.mm

@@ -31,6 +31,7 @@
 #import "OneSignalBridgeUtil.h"
 
 typedef void (*StringListenerDelegate)(const char* response);
+typedef void (*ClickListenerDelegate)(const char* message, const char* result, int urlType);
 
 /*
  * Helpers
@@ -39,29 +40,18 @@ typedef void (*StringListenerDelegate)(const char* response);
 #define CALLBACK(value) callback(hashCode, value)
 #define TO_NSSTRING(cstr) cstr ? [NSString stringWithUTF8String:cstr] : nil
 
-template <typename TObj>
-TObj objFromJsonString(const char* jsonString) {
-    NSData* jsonData = [[NSString stringWithUTF8String:jsonString] dataUsingEncoding:NSUTF8StringEncoding];
-    NSError* error = nil;
-    TObj arr = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
-
-    if (error != nil)
-        return nil;
-
-    return arr;
-}
-
 /*
  * Observer singleton for global callbacks
  */
 
-@interface OneSignalInAppMessagesObserver : NSObject <OSInAppMessageLifecycleHandler>
+@interface OneSignalInAppMessagesObserver : NSObject <OSInAppMessageLifecycleListener, OSInAppMessageClickListener>
 
 + (instancetype) sharedInAppMessagesObserver;
 @property StringListenerDelegate willDisplayDelegate;
 @property StringListenerDelegate didDisplayDelegate;
 @property StringListenerDelegate willDismissDelegate;
 @property StringListenerDelegate didDismissDelegate;
+@property ClickListenerDelegate clickDelegate;
 
 @end
 
@@ -78,30 +68,39 @@ TObj objFromJsonString(const char* jsonString) {
 
 - (instancetype) init {
     if (self = [super init]) {
-        [OneSignal.InAppMessages setLifecycleHandler:self];
+        [OneSignal.InAppMessages addLifecycleListener:self];
+        [OneSignal.InAppMessages addClickListener:self];
     }
 
     return self;
 }
 
-- (void)onWillDisplayInAppMessage:(OSInAppMessage *)message {
+- (void)onWillDisplayInAppMessage:(OSInAppMessageWillDisplayEvent *)event {
     if (_willDisplayDelegate != nil)
-        _willDisplayDelegate([message.messageId UTF8String]);
+        _willDisplayDelegate([event.message.messageId UTF8String]);
 }
 
-- (void)onDidDisplayInAppMessage:(OSInAppMessage *)message {
+- (void)onDidDisplayInAppMessage:(OSInAppMessageDidDisplayEvent *)event {
     if (_didDisplayDelegate != nil)
-        _didDisplayDelegate([message.messageId UTF8String]);
+        _didDisplayDelegate([event.message.messageId UTF8String]);
 }
 
-- (void)onWillDismissInAppMessage:(OSInAppMessage *)message {
+- (void)onWillDismissInAppMessage:(OSInAppMessageWillDismissEvent *)event {
     if (_willDismissDelegate != nil)
-        _willDismissDelegate([message.messageId UTF8String]);
+        _willDismissDelegate([event.message.messageId UTF8String]);
 }
 
-- (void)onDidDismissInAppMessage:(OSInAppMessage *)message {
+- (void)onDidDismissInAppMessage:(OSInAppMessageDidDismissEvent *)event {
     if (_didDismissDelegate != nil)
-        _didDismissDelegate([message.messageId UTF8String]);
+        _didDismissDelegate([event.message.messageId UTF8String]);
+}
+
+- (void)onClickInAppMessage:(OSInAppMessageClickEvent * _Nonnull)event {
+    if (_clickDelegate != nil) {
+        auto message = jsonStringFromDictionary([[event message] jsonRepresentation]);
+        auto result = jsonStringFromDictionary([[event result] jsonRepresentation]);
+        _clickDelegate(message, result, event.result.urlTarget);
+    }
 }
 
 @end
@@ -127,10 +126,8 @@ extern "C" {
         [[OneSignalInAppMessagesObserver sharedInAppMessagesObserver] setDidDismissDelegate:callback];
     }
 
-    void _inAppMessagesSetClickedCallback(StringListenerDelegate callback) {
-        [OneSignal.InAppMessages setClickHandler:^(OSInAppMessageAction * _Nonnull action) {
-            callback(jsonStringFromDictionary([action jsonRepresentation]));
-        }];
+    void _inAppMessagesSetClickCallback(ClickListenerDelegate callback) {
+        [[OneSignalInAppMessagesObserver sharedInAppMessagesObserver] setClickDelegate:callback];
     }
 
     void _inAppMessagesSetPaused(bool paused) {
@@ -146,7 +143,7 @@ extern "C" {
     }
 
     void _inAppMessagesAddTriggers(const char* triggersJson) {
-        NSDictionary *triggers = objFromJsonString<NSDictionary*>(triggersJson);
+        NSDictionary *triggers = dictionaryFromJsonString(triggersJson);
 
         [OneSignal.InAppMessages addTriggers:triggers];
     }
@@ -156,7 +153,7 @@ extern "C" {
     }
 
     void _inAppMessagesRemoveTriggers(const char* triggersJson) {
-        NSArray *triggers = objFromJsonString<NSArray*>(triggersJson);
+        NSArray *triggers = arrayFromJsonString(triggersJson);
 
         [OneSignal.InAppMessages removeTriggers:triggers];
     }

package/Runtime/Plugins/iOS/OneSignalUnityBridgeLiveActivities.mm

@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+#import <OneSignalNotifications/OneSignalNotifications.h>
+#import <OneSignalUser/OneSignalUser-Swift.h>
+#import <OneSignalFramework/OneSignalFramework.h>
+
+typedef void (*BooleanResponseDelegate)(int hashCode, bool response);
+
+/*
+ * Helpers
+ */
+
+#define CALLBACK(value) callback(hashCode, value)
+#define TO_NSSTRING(cstr) cstr ? [NSString stringWithUTF8String:cstr] : nil
+
+/*
+ * Bridge methods
+ */
+
+extern "C" {
+    void _enterLiveActivity(const char* activityId, const char* token, int hashCode, BooleanResponseDelegate callback) {
+        [OneSignal.LiveActivities enter:TO_NSSTRING(activityId)
+                        withToken:TO_NSSTRING(token)
+                        withSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+                        withFailure:^(NSError *error) { CALLBACK(NO); }];
+    }
+
+    void _exitLiveActivity(const char* activityId, int hashCode, BooleanResponseDelegate callback) {
+        [OneSignal.LiveActivities exit:TO_NSSTRING(activityId)
+                        withSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+                        withFailure:^(NSError *error) { CALLBACK(NO); }];
+    }
+}

package/Runtime/Plugins/iOS/OneSignalUnityBridgeLiveActivities.mm.meta

@@ -0,0 +1,37 @@
+fileFormatVersion: 2
+guid: af87776925bf8438bba2006c390b5306
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Plugins/iOS/OneSignalUnityBridgeNotifications.mm

@@ -31,9 +31,9 @@
 #import "OneSignalBridgeUtil.h"
 
 typedef void (*BooleanResponseDelegate)(int hashCode, bool response);
-typedef void (*StringListenerDelegate)(const char* response);
-typedef void (*StateListenerDelegate)(const char* current);
-typedef bool (*NotificationWillShowDelegate)(const char* notification);
+typedef void (*PermissionListenerDelegate)(bool permission);
+typedef void (*WillDisplayListenerDelegate)(const char* notification);
+typedef void (*ClickListenerDelegate)(const char* notification, const char* resultActionId, const char* resultUrl);
 
 /*
  * Helpers
@@ -45,10 +45,13 @@ typedef bool (*NotificationWillShowDelegate)(const char* notification);
  * Observer singleton for global callbacks
  */
 
-@interface OneSignalNotificationsObserver : NSObject <OSPermissionObserver>
+@interface OneSignalNotificationsObserver : NSObject <OSNotificationPermissionObserver, OSNotificationLifecycleListener, OSNotificationClickListener>
 
 + (instancetype) sharedNotificationsObserver;
-@property StateListenerDelegate permissionDelegate;
+@property PermissionListenerDelegate permissionDelegate;
+@property WillDisplayListenerDelegate willDisplayDelegate;
+@property ClickListenerDelegate clickDelegate;
+@property NSMutableDictionary<NSString *, id> *willDisplayEvents;
 
 @end
 
@@ -66,15 +69,44 @@ typedef bool (*NotificationWillShowDelegate)(const char* notification);
 - (instancetype) init {
     if (self = [super init]) {
         [OneSignal.Notifications addPermissionObserver:self];
+        [OneSignal.Notifications addForegroundLifecycleListener:self];
+        [OneSignal.Notifications addClickListener:self];
     }
 
     return self;
 }
 
-- (void)onOSPermissionChanged:(OSPermissionState*)state {
+- (void)onNotificationPermissionDidChange:(BOOL)permission {
     if (_permissionDelegate != nil) {
-        auto curr = jsonStringFromDictionary([state jsonRepresentation]);
-        _permissionDelegate(curr);
+        _permissionDelegate(permission);
+    }
+}
+
+- (void)onWillDisplayNotification:(OSNotificationWillDisplayEvent *)event {
+    if (_willDisplayDelegate != nil) {
+        NSString *stringNotification = [event.notification stringify];
+        _willDisplayDelegate([stringNotification UTF8String]);
+
+        _willDisplayEvents[event.notification.notificationId] = event;
+    }
+}
+
+- (void)notificationsWillDisplayEventPreventDefault:(NSString *)notificationId {
+    OSNotificationWillDisplayEvent *event = _willDisplayEvents[notificationId];
+    [event preventDefault];
+}
+
+- (void)notificationsDisplay:(NSString *)notificationId {
+    OSNotificationWillDisplayEvent *event = _willDisplayEvents[notificationId];
+    [event.notification display];
+}
+
+- (void)onClickNotification:(OSNotificationClickEvent * _Nonnull)event {
+    if (_clickDelegate != nil) {
+        NSString *stringNotification = [event.notification stringify];
+        NSString *stringResultActionId = event.result.actionId;
+        NSString *stringResultUrl = event.result.url;
+        _clickDelegate([stringNotification UTF8String], [stringResultActionId UTF8String], [stringResultUrl UTF8String]);
     }
 }
 
@@ -89,9 +121,13 @@ extern "C" {
         return [OneSignal.Notifications permission];
     }
 
-    /*bool _notificationsGetCanRequestPermission() {
+    bool _notificationsGetCanRequestPermission() {
         return [OneSignal.Notifications canRequestPermission];
-    }*/
+    }
+
+    int _notificationsGetPermissionNative() {
+        return [OneSignal.Notifications permissionNative];
+    }
 
     void _notificationsClearAll() {
         [OneSignal.Notifications clearAll];
@@ -103,22 +139,25 @@ extern "C" {
         } fallbackToSettings:fallbackToSettings];
     }
 
-    void _notificationsAddPermissionStateChangedCallback(StateListenerDelegate callback) {
+    void _notificationsAddPermissionObserver(PermissionListenerDelegate callback) {
         [[OneSignalNotificationsObserver sharedNotificationsObserver] setPermissionDelegate:callback];
     }
 
-    void _notificationsSetWillShowHandler(NotificationWillShowDelegate callback) {
-        [OneSignal.Notifications setNotificationWillShowInForegroundHandler:^(OSNotification *notification, OSNotificationDisplayResponse completion) {
-            NSString *stringResponse = [notification stringify];
-            bool shouldDisplay = callback([stringResponse UTF8String]);
-            completion(shouldDisplay ? notification : nil);
-        }];
+    void _notificationsSetForegroundWillDisplayCallback(WillDisplayListenerDelegate callback) {
+        [[OneSignalNotificationsObserver sharedNotificationsObserver] setWillDisplayDelegate:callback];
+    }
+
+    void _notificationsWillDisplayEventPreventDefault(const char* notifcationId) {
+        NSString *key = [NSString stringWithUTF8String:notifcationId];
+        [[OneSignalNotificationsObserver sharedNotificationsObserver] notificationsWillDisplayEventPreventDefault:key];
+    }
+
+    void _notificationsDisplay(const char* notifcationId) {
+        NSString *key = [NSString stringWithUTF8String:notifcationId];
+        [[OneSignalNotificationsObserver sharedNotificationsObserver] notificationsDisplay:key];
     }
 
-    void _notificationsSetOpenedHandler(StringListenerDelegate callback) {
-        [OneSignal.Notifications setNotificationOpenedHandler:^(OSNotificationOpenedResult * _Nonnull result) {
-            NSString *stringResponse = [result stringify];
-            callback([stringResponse UTF8String]);
-        }];
+    void _notificationsSetClickCallback(ClickListenerDelegate callback) {
+        [[OneSignalNotificationsObserver sharedNotificationsObserver] setClickDelegate:callback];
     }
 }

package/Runtime/Plugins/iOS/OneSignalUnityBridgeUser.mm

@@ -38,18 +38,6 @@ typedef void (*StateListenerDelegate)(const char* current, const char* previous)
 
 #define TO_NSSTRING(cstr) cstr ? [NSString stringWithUTF8String:cstr] : nil
 
-template <typename TObj>
-TObj objFromJsonString2(const char* jsonString) {
-    NSData* jsonData = [[NSString stringWithUTF8String:jsonString] dataUsingEncoding:NSUTF8StringEncoding];
-    NSError* error = nil;
-    TObj arr = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
-
-    if (error != nil)
-        return nil;
-
-    return arr;
-}
-
 /*
  * Observer singleton for global callbacks
  */
@@ -80,10 +68,10 @@ TObj objFromJsonString2(const char* jsonString) {
     return self;
 }
 
-- (void)onOSPushSubscriptionChangedWithStateChanges:(OSPushSubscriptionStateChanges*)stateChanges {
+- (void)onPushSubscriptionDidChangeWithState:(OSPushSubscriptionChangedState*)state {
     if (_pushSubscriptionDelegate != nil) {
-        auto curr = jsonStringFromDictionary([[stateChanges to] jsonRepresentation]);
-        auto prev = jsonStringFromDictionary([[stateChanges from] jsonRepresentation]);
+        auto curr = jsonStringFromDictionary([[state current] jsonRepresentation]);
+        auto prev = jsonStringFromDictionary([[state previous] jsonRepresentation]);
         _pushSubscriptionDelegate(curr, prev);
     }
 }
@@ -109,7 +97,7 @@ extern "C" {
     }
 
     void _userAddAliases(const char* aliasesJson) {
-        NSDictionary *aliases = objFromJsonString2<NSDictionary*>(aliasesJson);
+        NSDictionary *aliases = dictionaryFromJsonString(aliasesJson);
 
         [OneSignal.User addAliases:aliases];
     }
@@ -119,7 +107,7 @@ extern "C" {
     }
 
     void _userRemoveAliases(const char* aliasesJson) {
-        NSArray *aliases = objFromJsonString2<NSArray*>(aliasesJson);
+        NSArray *aliases = arrayFromJsonString(aliasesJson);
 
         if (aliases == nil) {
             NSLog(@"[Onesignal] Could not parse aliases to delete");
@@ -151,7 +139,7 @@ extern "C" {
     }
 
     void _userAddTags(const char* tagsJson) {
-        NSDictionary *tags = objFromJsonString2<NSDictionary*>(tagsJson);
+        NSDictionary *tags = dictionaryFromJsonString(tagsJson);
 
         [OneSignal.User addTags:tags];
     }
@@ -161,7 +149,7 @@ extern "C" {
     }
 
     void _userRemoveTags(const char* tagsJson) {
-        NSArray *tags = objFromJsonString2<NSArray*>(tagsJson);
+        NSArray *tags = arrayFromJsonString(tagsJson);
 
         if (tags == nil) {
             NSLog(@"[Onesignal] Could not parse tags to delete");

package/Runtime/iOSDisplayableNotification.cs

@@ -0,0 +1,41 @@
+/*
+ * 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 System.Runtime.InteropServices;
+using OneSignalSDK.Notifications.Internal;
+using OneSignalSDK.Notifications.Models;
+
+namespace OneSignalSDK.iOS.Notifications.Models {
+    public sealed class iOSDisplayableNotification : Notification, IDisplayableNotification {
+        [DllImport("__Internal")] private static extern void _notificationsDisplay(string notificationId);
+
+        public void Display()
+            => _notificationsDisplay(this.NotificationId);
+    }
+}

package/Runtime/iOSDisplayableNotification.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e6793593f96f42a498eb244efe9895a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/iOSInAppMessagesManager.cs

@@ -27,10 +27,12 @@
 
 
 using UnityEngine;
+using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using OneSignalSDK.InAppMessages;
 using OneSignalSDK.InAppMessages.Models;
+using OneSignalSDK.InAppMessages.Internal;
 
 namespace OneSignalSDK.iOS.InAppMessages {
     internal sealed class iOSInAppMessagesManager : IInAppMessagesManager {
@@ -38,7 +40,7 @@ namespace OneSignalSDK.iOS.InAppMessages {
         [DllImport("__Internal")] private static extern void _inAppMessagesSetDidDisplayCallback(StringListenerDelegate callback);
         [DllImport("__Internal")] private static extern void _inAppMessagesSetWillDismissCallback(StringListenerDelegate callback);
         [DllImport("__Internal")] private static extern void _inAppMessagesSetDidDismissCallback(StringListenerDelegate callback);
-        [DllImport("__Internal")] private static extern void _inAppMessagesSetClickedCallback(StringListenerDelegate callback);
+        [DllImport("__Internal")] private static extern void _inAppMessagesSetClickCallback(ClickListenerDelegate callback);
 
         [DllImport("__Internal")] private static extern void _inAppMessagesSetPaused(bool paused);
         [DllImport("__Internal")] private static extern bool _inAppMessagesGetPaused();
@@ -49,13 +51,13 @@ namespace OneSignalSDK.iOS.InAppMessages {
         [DllImport("__Internal")] private static extern void _inAppMessagesClearTriggers();
 
         private delegate void StringListenerDelegate(string response);
+        private delegate void ClickListenerDelegate(string message, string result, int urlType);
 
-        public event InAppMessageLifecycleDelegate WillDisplay;
-        public event InAppMessageLifecycleDelegate DidDisplay;
-        public event InAppMessageLifecycleDelegate WillDismiss;
-        public event InAppMessageLifecycleDelegate DidDismiss;
-
-        public event InAppMessageClickedDelegate Clicked;
+        public event EventHandler<InAppMessageWillDisplayEventArgs> WillDisplay;
+        public event EventHandler<InAppMessageDidDisplayEventArgs> DidDisplay;
+        public event EventHandler<InAppMessageWillDismissEventArgs> WillDismiss;
+        public event EventHandler<InAppMessageDidDismissEventArgs> DidDismiss;
+        public event EventHandler<InAppMessageClickEventArgs> Clicked;
 
         private static iOSInAppMessagesManager _instance;
 
@@ -68,10 +70,10 @@ namespace OneSignalSDK.iOS.InAppMessages {
             set => _inAppMessagesSetPaused(value);
         }
 
-        public void AddTrigger(string key, object value)
-            => _inAppMessagesAddTrigger(key, value.ToString()); // test
+        public void AddTrigger(string key, string value)
+            => _inAppMessagesAddTrigger(key, value.ToString());
 
-        public void AddTriggers(Dictionary<string, object> triggers) // <string, string> to <string, object>
+        public void AddTriggers(Dictionary<string, string> triggers)
             => _inAppMessagesAddTriggers(Json.Serialize(triggers));
 
         public void RemoveTrigger(string key)
@@ -88,31 +90,86 @@ namespace OneSignalSDK.iOS.InAppMessages {
             _inAppMessagesSetDidDisplayCallback(_onDidDisplay);
             _inAppMessagesSetWillDismissCallback(_onWillDismiss);
             _inAppMessagesSetDidDismissCallback(_onDidDismiss);
-            _inAppMessagesSetClickedCallback(_onClicked);
+            _inAppMessagesSetClickCallback(_onClicked);
         }
 
         [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
-        private static void _onWillDisplay(string response)
-            =>  UnityMainThreadDispatch.Post(state => _instance.WillDisplay?.Invoke(new InAppMessage { messageId = response }));
+        private static void _onWillDisplay(string response) {
+            var message = new InAppMessage(response);
+            InAppMessageWillDisplayEventArgs args = new InAppMessageWillDisplayEventArgs(message);
+
+            EventHandler<InAppMessageWillDisplayEventArgs> handler = _instance.WillDisplay;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
+        }
 
         [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
-        private static void _onDidDisplay(string response)
-            =>  UnityMainThreadDispatch.Post(state => _instance.DidDisplay?.Invoke(new InAppMessage { messageId = response }));
+        private static void _onDidDisplay(string response) {
+            var message = new InAppMessage(response);
+            InAppMessageDidDisplayEventArgs args = new InAppMessageDidDisplayEventArgs(message);
+
+            EventHandler<InAppMessageDidDisplayEventArgs> handler = _instance.DidDisplay;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
+        }
 
         [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
-        private static void _onWillDismiss(string response)
-            =>  UnityMainThreadDispatch.Post(state => _instance.WillDismiss?.Invoke(new InAppMessage { messageId = response }));
+        private static void _onWillDismiss(string response) {
+            var message = new InAppMessage(response);
+            InAppMessageWillDismissEventArgs args = new InAppMessageWillDismissEventArgs(message);
+
+            EventHandler<InAppMessageWillDismissEventArgs> handler = _instance.WillDismiss;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
+        }
 
         [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
-        private static void _onDidDismiss(string response)
-            =>  UnityMainThreadDispatch.Post(state => _instance.DidDismiss?.Invoke(new InAppMessage { messageId = response }));
-
-        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))] // iOS returns InAppMessageAction. Android returns InAppMessageClickedResult
-        private static void _onClicked(string response) {
-            InAppMessageClickedResult temp = new InAppMessageClickedResult();
-            temp.action = JsonUtility.FromJson<InAppMessageAction>(response);
-            //temp.message = new InAppMessage { messageId = "messageIdTemp" };
-            UnityMainThreadDispatch.Post(state => _instance.Clicked?.Invoke(temp));
+        private static void _onDidDismiss(string response) {
+            var message = new InAppMessage(response);
+            InAppMessageDidDismissEventArgs args = new InAppMessageDidDismissEventArgs(message);
+
+            EventHandler<InAppMessageDidDismissEventArgs> handler = _instance.DidDismiss;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(ClickListenerDelegate))]
+        private static void _onClicked(string message, string result, int urlType) {
+            var mes = JsonUtility.FromJson<InAppMessage>(message);
+            var res = JsonUtility.FromJson<InAppMessageClickResult>(result);
+
+            var urlTarget = IntToInAppMessageActionUrlType(urlType);
+            var clickRes = new InAppMessageClickResult(res.ActionId, urlTarget, res.Url, res.ClosingMessage);
+
+            InAppMessageClickEventArgs args = new InAppMessageClickEventArgs(mes, clickRes);
+
+            EventHandler<InAppMessageClickEventArgs> handler = _instance.Clicked;
+            if (handler != null)
+            {
+                UnityMainThreadDispatch.Post(state => handler(_instance, args));
+            }
+        }
+
+        public static InAppMessageActionUrlType IntToInAppMessageActionUrlType(int urlType) {
+            switch (urlType)
+            {
+                case 0:
+                    return InAppMessageActionUrlType.Browser;
+                case 1:
+                    return InAppMessageActionUrlType.InAppWebview;
+                case 2:
+                    return InAppMessageActionUrlType.RepalceContent;
+                default:
+                    return null;
+            }
         }
     }
 }

package/Runtime/iOSLiveActivitiesManager.cs

@@ -0,0 +1,56 @@
+/*
+ * 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.Threading.Tasks;
+using System.Runtime.InteropServices;
+using OneSignalSDK.LiveActivities;
+using OneSignalSDK.iOS.Utilities;
+
+namespace OneSignalSDK.iOS.LiveActivities {
+    internal sealed class iOSLiveActivitiesManager : ILiveActivitiesManager {
+        [DllImport("__Internal")] private static extern void _enterLiveActivity(string activityId, string token, int hashCode, BooleanResponseDelegate callback);
+        [DllImport("__Internal")] private static extern void _exitLiveActivity(string activityId, int hashCode, BooleanResponseDelegate callback);
+
+        private delegate void BooleanResponseDelegate(int hashCode, bool response);
+
+        public async Task<bool> EnterAsync(string activityId, string token) {
+            var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
+            _enterLiveActivity(activityId, token, hashCode, BooleanCallbackProxy);
+            return await proxy;
+        }
+
+        public async Task<bool> ExitAsync(string activityId) {
+            var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
+            _exitLiveActivity(activityId, hashCode, BooleanCallbackProxy);
+            return await proxy;
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(BooleanResponseDelegate))]
+        private static void BooleanCallbackProxy(int hashCode, bool response)
+            => WaitingProxy.ResolveCallbackProxy(hashCode, response);
+    }
+}

package/Runtime/iOSLiveActivitiesManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0831e8d503194992a290b893af97a6a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/iOSLocationManager.cs

@@ -41,8 +41,9 @@ namespace OneSignalSDK.iOS.Location {
             set => _locationSetIsShared(value);
         }
 
-        public void RequestPermission() { // iOS make async
+        public Task<bool> RequestPermissionAsync() { // iOS not async yet
             _locationRequestPermission();
+            return Task.FromResult(true);
         }
     }
 }

package/Runtime/iOSNotificationsManager.cs

@@ -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

@@ -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/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-beta.3",
   "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-beta.3"
   },
   "keywords": [
     "push-notifications",