com.onesignal.unity.ios 3.0.8 → 5.0.0-beta.1

package/Runtime/iOSDebugManager.cs

@@ -0,0 +1,57 @@
+/*
+ * 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 UnityEngine;
+using System.Runtime.InteropServices;
+using OneSignalSDK.Debug;
+using OneSignalSDK.Debug.Models;
+
+namespace OneSignalSDK.iOS.Debug {
+    internal sealed class iOSDebugManager : IDebugManager {
+        [DllImport("__Internal")] private static extern void _debugSetLogLevel(int logLevel);
+        [DllImport("__Internal")] private static extern void _debugSetAlertLevel(int alertlLevel);
+
+        private LogLevel _logLevel = LogLevel.Warn;
+        private LogLevel _alertLevel = LogLevel.None;
+
+        public LogLevel LogLevel {
+            get => _logLevel;
+            set {
+                _logLevel = value;
+                _debugSetLogLevel((int) value);
+            }
+        }
+
+        public LogLevel AlertLevel {
+            get => _alertLevel;
+            set {
+                _alertLevel = value;
+                _debugSetAlertLevel((int) value);
+            }
+        }
+    }
+}

package/Runtime/iOSDebugManager.cs.meta

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

package/Runtime/iOSInAppMessagesManager.cs

@@ -0,0 +1,118 @@
+/*
+ * 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 UnityEngine;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using OneSignalSDK.InAppMessages;
+using OneSignalSDK.InAppMessages.Models;
+
+namespace OneSignalSDK.iOS.InAppMessages {
+    internal sealed class iOSInAppMessagesManager : IInAppMessagesManager {
+        [DllImport("__Internal")] private static extern void _inAppMessagesSetWillDisplayCallback(StringListenerDelegate callback);
+        [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 _inAppMessagesSetPaused(bool paused);
+        [DllImport("__Internal")] private static extern bool _inAppMessagesGetPaused();
+        [DllImport("__Internal")] private static extern void _inAppMessagesAddTrigger(string key, string value);
+        [DllImport("__Internal")] private static extern void _inAppMessagesAddTriggers(string triggersJson);
+        [DllImport("__Internal")] private static extern void _inAppMessagesRemoveTrigger(string key);
+        [DllImport("__Internal")] private static extern void _inAppMessagesRemoveTriggers(string triggersJson);
+        [DllImport("__Internal")] private static extern void _inAppMessagesClearTriggers();
+
+        private delegate void StringListenerDelegate(string response);
+
+        public event InAppMessageLifecycleDelegate WillDisplay;
+        public event InAppMessageLifecycleDelegate DidDisplay;
+        public event InAppMessageLifecycleDelegate WillDismiss;
+        public event InAppMessageLifecycleDelegate DidDismiss;
+
+        public event InAppMessageClickedDelegate Clicked;
+
+        private static iOSInAppMessagesManager _instance;
+
+        public iOSInAppMessagesManager() {
+            _instance = this;
+        }
+
+        public bool Paused {
+            get => _inAppMessagesGetPaused();
+            set => _inAppMessagesSetPaused(value);
+        }
+
+        public void AddTrigger(string key, object value)
+            => _inAppMessagesAddTrigger(key, value.ToString()); // test
+
+        public void AddTriggers(Dictionary<string, object> triggers) // <string, string> to <string, object>
+            => _inAppMessagesAddTriggers(Json.Serialize(triggers));
+
+        public void RemoveTrigger(string key)
+            => _inAppMessagesRemoveTrigger(key);
+
+        public void RemoveTriggers(params string[] keys)
+            => _inAppMessagesRemoveTriggers(Json.Serialize(keys));
+
+        public void ClearTriggers()
+            => _inAppMessagesClearTriggers();
+
+        public void Initialize() {
+            _inAppMessagesSetWillDisplayCallback(_onWillDisplay);
+            _inAppMessagesSetDidDisplayCallback(_onDidDisplay);
+            _inAppMessagesSetWillDismissCallback(_onWillDismiss);
+            _inAppMessagesSetDidDismissCallback(_onDidDismiss);
+            _inAppMessagesSetClickedCallback(_onClicked);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
+        private static void _onWillDisplay(string response)
+            =>  UnityMainThreadDispatch.Post(state => _instance.WillDisplay?.Invoke(new InAppMessage { messageId = response }));
+
+        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
+        private static void _onDidDisplay(string response)
+            =>  UnityMainThreadDispatch.Post(state => _instance.DidDisplay?.Invoke(new InAppMessage { messageId = response }));
+
+        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
+        private static void _onWillDismiss(string response)
+            =>  UnityMainThreadDispatch.Post(state => _instance.WillDismiss?.Invoke(new InAppMessage { messageId = response }));
+
+        [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));
+        }
+    }
+}

package/Runtime/iOSInAppMessagesManager.cs.meta

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

package/Runtime/iOSLocationManager.cs

@@ -0,0 +1,48 @@
+/*
+ * 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 UnityEngine;
+using System.Threading.Tasks;
+using OneSignalSDK.Location;
+using System.Runtime.InteropServices;
+
+namespace OneSignalSDK.iOS.Location {
+    internal sealed class iOSLocationManager : ILocationManager {
+        [DllImport("__Internal")] private static extern bool _locationGetIsShared();
+        [DllImport("__Internal")] private static extern void _locationSetIsShared(bool shared);
+        [DllImport("__Internal")] private static extern void _locationRequestPermission();
+
+        public bool IsShared {
+            get => _locationGetIsShared();
+            set => _locationSetIsShared(value);
+        }
+
+        public void RequestPermission() { // iOS make async
+            _locationRequestPermission();
+        }
+    }
+}

package/Runtime/iOSLocationManager.cs.meta

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

package/Runtime/iOSNotificationsManager.cs

@@ -0,0 +1,148 @@
+/*
+ * 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.Threading.Tasks;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using OneSignalSDK.Notifications;
+using OneSignalSDK.Notifications.Models;
+using OneSignalSDK.iOS.Utilities;
+
+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 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);
+        private delegate void BooleanResponseDelegate(int hashCode, bool response);
+
+        public event NotificationWillShowDelegate WillShow;
+        public event NotificationClickedDelegate Clicked;
+        public event PermissionChangedDelegate PermissionChanged;
+
+        private static iOSNotificationsManager _instance;
+
+        public iOSNotificationsManager() {
+            _instance = this;
+        }
+
+        public bool Permission {
+            get => _notificationsGetPermission();
+        }
+
+        public async Task<bool> RequestPermissionAsync(bool fallbackToSettings) {
+            var (proxy, hashCode) = WaitingProxy._setupProxy<bool>();
+            _notificationsRequestPermission(fallbackToSettings, hashCode, BooleanCallbackProxy);
+            return await proxy;
+        }
+
+        public void ClearAllNotifications() {
+            _notificationsClearAll();
+        }
+
+        public void Initialize() {
+            _notificationsAddPermissionStateChangedCallback(_onPermissionStateChanged);
+            _notificationsSetWillShowHandler(_onWillShow);
+            _notificationsSetOpenedHandler(_onOpened);
+        }
+
+        [AOT.MonoPInvokeCallback(typeof(StateListenerDelegate))]
+        private static void _onPermissionStateChanged(string current) {
+            var curr = JsonUtility.FromJson<PermissionState>(current);
+            UnityMainThreadDispatch.Post(state => _instance.PermissionChanged?.Invoke(curr.permission));
+        }
+
+        /// <param name="response">OSNotification</param>
+        [AOT.MonoPInvokeCallback(typeof(NotificationWillShowInForegroundDelegate))]
+        private static bool _onWillShow(string response) {
+            if (_instance.WillShow == null)
+                return true;
+
+            var notification = JsonUtility.FromJson<Notification>(response);
+            _fillNotifFromObj(ref notification, Json.Deserialize(response));
+
+            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);});
+
+            return resultNotif != null;
+        }
+
+        /// <param name="response">OSNotificationOpenedResult</param>
+        [AOT.MonoPInvokeCallback(typeof(StringListenerDelegate))]
+        private static void _onOpened(string response) {
+            var notifOpenResult = JsonUtility.FromJson<NotificationClickedResult>(response);
+
+            if (Json.Deserialize(response) is Dictionary<string, object> resultDict && resultDict.ContainsKey("notification"))
+                _fillNotifFromObj(ref notifOpenResult.notification, resultDict["notification"]);
+
+            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));
+                }
+                
+                OneSignal.OnInitialize += invokeOpened; 
+            }
+        }
+
+        private static void _fillNotifFromObj(ref Notification notif, object notifObj) {
+            if (!(notifObj is Dictionary<string, object> notifDict)) 
+                return;
+            
+            if (notifDict.ContainsKey("additionalData"))
+                notif.additionalData = notifDict["additionalData"] as Dictionary<string, object>;
+            
+            if (notifDict.ContainsKey("attachments"))
+                notif.attachments = notifDict["attachments"] as Dictionary<string, object>;
+
+            if (notifDict.ContainsKey("rawPayload") && notifDict["rawPayload"] is Dictionary<string, object> payloadDict)
+                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/iOSNotificationsManager.cs.meta

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

package/Runtime/iOSPushSubscription.cs

@@ -0,0 +1,81 @@
+/*
+ * 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.User.Models;
+
+namespace OneSignalSDK.iOS.User.Models {
+    internal sealed class iOSPushSubscription : IPushSubscription {
+        [DllImport("__Internal")] private static extern string _pushSubscriptionGetId();
+        [DllImport("__Internal")] private static extern string _pushSubscriptionGetToken();
+        [DllImport("__Internal")] private static extern bool _pushSubscriptionGetOptedIn();
+        [DllImport("__Internal")] private static extern void _pushSubscriptionOptIn();
+        [DllImport("__Internal")] private static extern void _pushSubscriptionOptOut();
+        [DllImport("__Internal")] private static extern void _pushSubscriptionAddStateChangedCallback(StateListenerDelegate callback);
+
+        public delegate void StateListenerDelegate(string current, string previous);
+
+        public event SubscriptionChangedDelegate Changed;
+
+        private static iOSPushSubscription _instance;
+
+        public iOSPushSubscription() {
+            _instance = this;
+        }
+
+        public string Id {
+            get => _pushSubscriptionGetId();
+        }
+
+        public string Token {
+            get => _pushSubscriptionGetToken();
+        }
+
+        public bool OptedIn {
+            get => _pushSubscriptionGetOptedIn();
+        }
+
+        public void OptIn()
+            => _pushSubscriptionOptIn();
+
+        public void OptOut()
+            => _pushSubscriptionOptOut();
+
+        public void Initialize() {
+            _pushSubscriptionAddStateChangedCallback(_onPushSubscriptionStateChanged);
+        }
+
+        [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));
+        }
+    }
+}

package/Runtime/iOSPushSubscription.cs.meta

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

package/Runtime/iOSSessionManager.cs

@@ -0,0 +1,47 @@
+/*
+ * 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 UnityEngine;
+using OneSignalSDK.Session;
+using System.Runtime.InteropServices;
+
+namespace OneSignalSDK.iOS.Session {
+    internal sealed class iOSSessionManager : ISessionManager {
+        [DllImport("__Internal")] private static extern void _sessionAddOutcome(string name);
+        [DllImport("__Internal")] private static extern void _sessionAddUniqueOutcome(string name);
+        [DllImport("__Internal")] private static extern void _sessionAddOutcomeWithValue(string name, float value);
+
+        public void AddOutcome(string name)
+            => _sessionAddOutcome(name);
+
+        public void AddUniqueOutcome(string name)
+            => _sessionAddUniqueOutcome(name);
+
+        public void AddOutcomeWithValue(string name, float value)
+            => _sessionAddOutcomeWithValue(name, value);
+    }
+}

package/Runtime/iOSSessionManager.cs.meta

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