fix: [SDK-5335] reject blank identity strings

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

@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using OneSignalSDK;
 using OneSignalSDK.Android.Utilities;
 using OneSignalSDK.InAppMessages;
 using OneSignalSDK.InAppMessages.Internal;
@@ -56,16 +57,38 @@ public bool Paused
             set => _inAppMessages.Call("setPaused", value);
         }
 
-        public void AddTrigger(string key, string value) =>
+        public void AddTrigger(string key, string value)
+        {
+            if (InputGuard.Missing(key, "addTrigger: key"))
+                return;
+            if (value == null)
+            {
+                UnityEngine.Debug.LogError("OneSignal: addTrigger: value is required");
+                return;
+            }
             _inAppMessages.Call("addTrigger", key, value);
+        }
 
-        public void AddTriggers(Dictionary<string, string> triggers) =>
+        public void AddTriggers(Dictionary<string, string> triggers)
+        {
+            if (InputGuard.MissingEntries(triggers, "addTriggers", true))
+                return;
             _inAppMessages.Call("addTriggers", triggers.ToMap());
+        }
 
-        public void RemoveTrigger(string key) => _inAppMessages.Call("removeTrigger", key);
+        public void RemoveTrigger(string key)
+        {
+            if (InputGuard.Missing(key, "removeTrigger: key"))
+                return;
+            _inAppMessages.Call("removeTrigger", key);
+        }
 
-        public void RemoveTriggers(params string[] keys) =>
+        public void RemoveTriggers(params string[] keys)
+        {
+            if (InputGuard.MissingAny(keys, "removeTriggers: key"))
+                return;
             _inAppMessages.Call("removeTriggers", keys.ToArrayList());
+        }
 
         public void ClearTriggers() => _inAppMessages.Call("clearTriggers");
 

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

@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using OneSignalSDK;
 using OneSignalSDK.Android.User.Models;
 using OneSignalSDK.Android.Utilities;
 using OneSignalSDK.User;
@@ -73,7 +74,16 @@ public IPushSubscription PushSubscription
 
         public string Language
         {
-            set => _user.Call("setLanguage", value);
+            set
+            {
+                // Empty string is the reset to the device language. Null is not.
+                if (value == null)
+                {
+                    Debug.LogError("OneSignal: setLanguage: language is required");
+                    return;
+                }
+                _user.Call("setLanguage", value);
+            }
         }
 
         public Dictionary<string, string> GetTags()
@@ -82,35 +92,104 @@ public Dictionary<string, string> GetTags()
             return obj.MapToDictionary();
         }
 
-        public void AddTag(string key, string value) => _user.Call("addTag", key, value);
+        public void AddTag(string key, string value)
+        {
+            if (InputGuard.Missing(key, "addTag: key"))
+                return;
+            if (value == null)
+            {
+                UnityEngine.Debug.LogError("OneSignal: addTag: value is required");
+                return;
+            }
+            _user.Call("addTag", key, value);
+        }
 
-        public void AddTags(Dictionary<string, string> tags) => _user.Call("addTags", tags.ToMap());
+        public void AddTags(Dictionary<string, string> tags)
+        {
+            if (InputGuard.MissingEntries(tags, "addTags", true))
+                return;
+            _user.Call("addTags", tags.ToMap());
+        }
 
-        public void RemoveTag(string key) => _user.Call("removeTag", key);
+        public void RemoveTag(string key)
+        {
+            if (InputGuard.Missing(key, "removeTag: key"))
+                return;
+            _user.Call("removeTag", key);
+        }
 
-        public void RemoveTags(params string[] keys) =>
+        public void RemoveTags(params string[] keys)
+        {
+            if (InputGuard.MissingAny(keys, "removeTags: key"))
+                return;
             _user.Call("removeTags", keys.ToArrayList());
+        }
 
-        public void AddAlias(string label, string id) => _user.Call("addAlias", label, id);
+        public void AddAlias(string label, string id)
+        {
+            if (
+                InputGuard.Missing(label, "addAlias: label")
+                || InputGuard.Missing(id, "addAlias: id")
+            )
+                return;
+            _user.Call("addAlias", label, id);
+        }
 
-        public void AddAliases(Dictionary<string, string> aliases) =>
+        public void AddAliases(Dictionary<string, string> aliases)
+        {
+            if (InputGuard.MissingEntries(aliases, "addAliases", false))
+                return;
             _user.Call("addAliases", aliases.ToMap());
+        }
 
-        public void RemoveAlias(string label) => _user.Call("removeAlias", label);
+        public void RemoveAlias(string label)
+        {
+            if (InputGuard.Missing(label, "removeAlias: label"))
+                return;
+            _user.Call("removeAlias", label);
+        }
 
-        public void RemoveAliases(params string[] labels) =>
+        public void RemoveAliases(params string[] labels)
+        {
+            if (InputGuard.MissingAny(labels, "removeAliases: label"))
+                return;
             _user.Call("removeAliases", labels.ToArrayList());
+        }
 
-        public void AddEmail(string email) => _user.Call("addEmail", email);
+        public void AddEmail(string email)
+        {
+            if (InputGuard.Missing(email, "addEmail: email"))
+                return;
+            _user.Call("addEmail", email);
+        }
 
-        public void RemoveEmail(string email) => _user.Call("removeEmail", email);
+        public void RemoveEmail(string email)
+        {
+            if (InputGuard.Missing(email, "removeEmail: email"))
+                return;
+            _user.Call("removeEmail", email);
+        }
 
-        public void AddSms(string sms) => _user.Call("addSms", sms);
+        public void AddSms(string sms)
+        {
+            if (InputGuard.Missing(sms, "addSms: sms"))
+                return;
+            _user.Call("addSms", sms);
+        }
 
-        public void RemoveSms(string sms) => _user.Call("removeSms", sms);
+        public void RemoveSms(string sms)
+        {
+            if (InputGuard.Missing(sms, "removeSms: sms"))
+                return;
+            _user.Call("removeSms", sms);
+        }
 
-        public void TrackEvent(string name, Dictionary<string, object> properties = null) =>
+        public void TrackEvent(string name, Dictionary<string, object> properties = null)
+        {
+            if (InputGuard.Missing(name, "trackEvent: name"))
+                return;
             _user.Call("trackEvent", name, properties?.ToMap());
+        }
 
         public void Initialize()
         {

com.onesignal.unity.core/Runtime/InputGuard.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace OneSignalSDK
+{
+    internal static class InputGuard
+    {
+        public static bool Missing(string value, string api)
+        {
+            if (!string.IsNullOrEmpty(value))
+                return false;
+            Debug.LogError("OneSignal: " + api + " is required");
+            return true;
+        }
+
+        public static bool MissingAny(string[] values, string api)
+        {
+            if (values == null)
+                return Missing(null, api);
+            foreach (var value in values)
+            {
+                if (Missing(value, api))
+                    return true;
+            }
+            return false;
+        }
+
+        public static bool MissingEntries(
+            IDictionary<string, string> values,
+            string api,
+            bool allowEmptyValue
+        )
+        {
+            if (values == null)
+                return Missing(null, api);
+            foreach (var pair in values)
+            {
+                if (Missing(pair.Key, api + ": key"))
+                    return true;
+                if (allowEmptyValue)
+                {
+                    if (pair.Value != null)
+                        continue;
+                    Debug.LogError("OneSignal: " + api + ": value is required");
+                    return true;
+                }
+                if (Missing(pair.Value, api + ": value"))
+                    return true;
+            }
+            return false;
+        }
+    }
+}

com.onesignal.unity.core/Runtime/OneSignal.cs

@@ -145,6 +145,8 @@ public static bool ConsentRequired
         /// <param name="appId">Your application id from the OneSignal dashboard</param>
         public static void Initialize(string appId)
         {
+            if (InputGuard.Missing(appId, "initialize: appId"))
+                return;
             OneSignal.Default.Initialize(appId);
         }
 
@@ -172,6 +174,8 @@ public static void Initialize(string appId)
         /// </param>
         public static void Login(string externalId, string jwtBearerToken = null)
         {
+            if (InputGuard.Missing(externalId, "login: externalId"))
+                return;
             OneSignal.Default.Login(externalId, jwtBearerToken);
         }
 

com.onesignal.unity.ios/Runtime/iOSInAppMessagesManager.cs

@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using OneSignalSDK;
 using OneSignalSDK.InAppMessages;
 using OneSignalSDK.InAppMessages.Internal;
 using OneSignalSDK.InAppMessages.Models;
@@ -105,16 +106,38 @@ public bool Paused
             set => _oneSignalInAppMessagesSetPaused(value);
         }
 
-        public void AddTrigger(string key, string value) =>
+        public void AddTrigger(string key, string value)
+        {
+            if (InputGuard.Missing(key, "addTrigger: key"))
+                return;
+            if (value == null)
+            {
+                Debug.LogError("OneSignal: addTrigger: value is required");
+                return;
+            }
             _oneSignalInAppMessagesAddTrigger(key, value.ToString());
+        }
 
-        public void AddTriggers(Dictionary<string, string> triggers) =>
+        public void AddTriggers(Dictionary<string, string> triggers)
+        {
+            if (InputGuard.MissingEntries(triggers, "addTriggers", true))
+                return;
             _oneSignalInAppMessagesAddTriggers(Json.Serialize(triggers));
+        }
 
-        public void RemoveTrigger(string key) => _oneSignalInAppMessagesRemoveTrigger(key);
+        public void RemoveTrigger(string key)
+        {
+            if (InputGuard.Missing(key, "removeTrigger: key"))
+                return;
+            _oneSignalInAppMessagesRemoveTrigger(key);
+        }
 
-        public void RemoveTriggers(params string[] keys) =>
+        public void RemoveTriggers(params string[] keys)
+        {
+            if (InputGuard.MissingAny(keys, "removeTriggers: key"))
+                return;
             _oneSignalInAppMessagesRemoveTriggers(Json.Serialize(keys));
+        }
 
         public void ClearTriggers() => _oneSignalInAppMessagesClearTriggers();