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

package/Runtime/OneSignalIOS.Callbacks.cs

@@ -99,6 +99,10 @@ namespace OneSignalSDK {
                 return true;
 
             var notification = JsonUtility.FromJson<Notification>(response);
+
+            if (Json.Deserialize(response) is Dictionary<string, object> notifDict && notifDict.ContainsKey("additionalData"))
+                notification.additionalData = notifDict["additionalData"] as Dictionary<string, object>;
+            
             var resultNotif  = _instance.NotificationWillShow(notification);
             
             return resultNotif != null;
@@ -130,9 +134,20 @@ namespace OneSignalSDK {
 
         [AOT.MonoPInvokeCallback(typeof(StateListenerDelegate))]
         private static void _onPermissionStateChanged(string current, string previous) {
-            var curr = JsonUtility.FromJson<PermissionState>(current);
-            var prev = JsonUtility.FromJson<PermissionState>(previous);
-            _instance.PermissionStateChanged?.Invoke(curr, prev);
+            if (!(Json.Deserialize(current) is Dictionary<string, object> currState)) {
+                SDKDebug.Error("Could not deserialize current permission state");
+                return;
+            }
+
+            if (!(Json.Deserialize(previous) is Dictionary<string, object> prevState)) {
+                SDKDebug.Error("Could not deserialize previous permission state");
+                return;
+            }
+            
+            var curr = (NotificationPermission) currState["status"];
+            var prev = (NotificationPermission) prevState["status"];
+            
+            _instance.NotificationPermissionChanged?.Invoke(curr, prev);
         }
         
         [AOT.MonoPInvokeCallback(typeof(StateListenerDelegate))]

package/Runtime/OneSignalIOS.Interface.cs

@@ -54,6 +54,9 @@ namespace OneSignalSDK {
          * Direct methods
          */
         
+        [DllImport("__Internal")] private static extern string _getDeviceState();
+        
+        [DllImport("__Internal")] private static extern void _setLogLevel(int logLevel, int alertLevel);
         [DllImport("__Internal")] private static extern void _setPrivacyConsent(bool consent);
         [DllImport("__Internal")] private static extern bool _getPrivacyConsent();
         [DllImport("__Internal")] private static extern void _setRequiresPrivacyConsent(bool required);
@@ -82,6 +85,8 @@ namespace OneSignalSDK {
 
         [DllImport("__Internal")] private static extern void _logoutEmail(int hashCode, BooleanResponseDelegate callback);
         [DllImport("__Internal")] private static extern void _logoutSMSNumber(int hashCode, BooleanResponseDelegate callback);
+        
+        [DllImport("__Internal")] private static extern void _setLanguage(string languageCode, int hashCode, BooleanResponseDelegate callback);
 
         [DllImport("__Internal")] private static extern void _promptLocation();
         [DllImport("__Internal")] private static extern void _setShareLocation(bool share);

package/Runtime/OneSignalIOS.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * Modified MIT License
  *
  * Copyright 2021 OneSignal
@@ -38,11 +38,83 @@ namespace OneSignalSDK {
         public override event InAppMessageLifecycleDelegate InAppMessageWillDismiss;
         public override event InAppMessageLifecycleDelegate InAppMessageDidDismiss;
         public override event InAppMessageActionDelegate InAppMessageTriggeredAction;
-        public override event StateChangeDelegate<PermissionState> PermissionStateChanged;
+        public override event StateChangeDelegate<NotificationPermission> NotificationPermissionChanged;
         public override event StateChangeDelegate<PushSubscriptionState> PushSubscriptionStateChanged;
         public override event StateChangeDelegate<EmailSubscriptionState> EmailSubscriptionStateChanged;
         public override event StateChangeDelegate<SMSSubscriptionState> SMSSubscriptionStateChanged;
+        
+        public override NotificationPermission NotificationPermission {
+            get {
+                if (Json.Deserialize(_getDeviceState()) is Dictionary<string, object> deviceState)
+                    return (NotificationPermission) deviceState["notificationPermissionStatus"];
+                
+                SDKDebug.Error("Could not deserialize device state for permissions");
+                return NotificationPermission.NotDetermined;
+            }
+        }
+        
+        public override PushSubscriptionState PushSubscriptionState {
+            get {
+                if (Json.Deserialize(_getDeviceState()) is Dictionary<string, object> deviceState) {
+                    return new PushSubscriptionState {
+                        userId         = deviceState["userId"] as string,
+                        pushToken      = deviceState["pushToken"] as string,
+                        isSubscribed   = (bool) deviceState["isSubscribed"],
+                        isPushDisabled = (bool) deviceState["isPushDisabled"],
+                    };
+                }
+
+                SDKDebug.Error("Could not deserialize device state for push");
+                return null;
+            }
+        }
+        
+        public override EmailSubscriptionState EmailSubscriptionState {
+            get {
+                if (Json.Deserialize(_getDeviceState()) is Dictionary<string, object> deviceState) {
+                    return new EmailSubscriptionState {
+                        emailUserId  = deviceState["emailUserId"] as string,
+                        emailAddress = deviceState["emailAddress"] as string,
+                        isSubscribed = (bool) deviceState["isEmailSubscribed"],
+                    };
+                }
 
+                SDKDebug.Error("Could not deserialize device state for email");
+                return null;
+            }
+        }
+        
+        public override SMSSubscriptionState SMSSubscriptionState {
+            get {
+                if (Json.Deserialize(_getDeviceState()) is Dictionary<string, object> deviceState) {
+                    return new SMSSubscriptionState {
+                        smsUserId    = deviceState["smsUserId"] as string,
+                        smsNumber    = deviceState["smsNumber"] as string,
+                        isSubscribed = (bool) deviceState["isSMSSubscribed"],
+                    };
+                }
+
+                SDKDebug.Error("Could not deserialize device state for sms");
+                return null;
+            }
+        }
+
+        public override LogLevel LogLevel {
+            get => _logLevel;
+            set {
+                _logLevel = value;
+                _setLogLevel((int) _logLevel, (int) _alertLevel);
+            }
+        }
+
+        public override LogLevel AlertLevel {
+            get => _alertLevel;
+            set {
+                _alertLevel = value;
+                _setLogLevel((int) _logLevel, (int) _alertLevel);
+            }
+        }
+        
         public override bool PrivacyConsent {
             get => _getPrivacyConsent();
             set => _setPrivacyConsent(value);
@@ -65,7 +137,7 @@ namespace OneSignalSDK {
         }
 
         public override void ClearOneSignalNotifications()
-            => SDKDebug.Log("ClearOneSignalNotifications invoked on iOS, does nothing");
+            => SDKDebug.Info("ClearOneSignalNotifications invoked on iOS, does nothing");
 
         public override async Task<Dictionary<string, object>> PostNotification(Dictionary<string, object> options) {
             var (proxy, hashCode) = _setupProxy<string>();
@@ -159,6 +231,12 @@ namespace OneSignalSDK {
             _logoutSMSNumber(hashCode, BooleanCallbackProxy);
             return await proxy;
         }
+        
+        public override async Task<bool> SetLanguage(string languageCode) {
+            var (proxy, hashCode) = _setupProxy<bool>();
+            _setLanguage(languageCode, hashCode, BooleanCallbackProxy);
+            return await proxy;
+        }
 
         public override void PromptLocation()
             => _promptLocation();

package/Runtime/Plugins/iOS/OneSignalUnityBridge.mm

@@ -67,10 +67,10 @@ const char* jsonStringFromDictionary(NSDictionary *dictionary) {
  */
 
 @interface OneSignalObserver : NSObject <OSPermissionObserver,
-                                         OSSubscriptionObserver,
-                                         OSEmailSubscriptionObserver,
-                                         OSSMSSubscriptionObserver,
-                                         OSInAppMessageLifecycleHandler>
+        OSSubscriptionObserver,
+        OSEmailSubscriptionObserver,
+        OSSMSSubscriptionObserver,
+        OSInAppMessageLifecycleHandler>
 
 + (instancetype) sharedObserver;
 @property StateListenerDelegate permissionDelegate;
@@ -167,234 +167,251 @@ const char* jsonStringFromDictionary(NSDictionary *dictionary) {
 
 extern "C" {
 
-    void _setNotificationReceivedCallback(NotificationWillShowInForegroundDelegate callback) {
-        [OneSignal setNotificationWillShowInForegroundHandler:^(OSNotification *notification, OSNotificationDisplayResponse completion) {
-            NSString *stringResponse = [notification stringify];
-            bool shouldDisplay = callback([stringResponse UTF8String]);
-            completion(shouldDisplay ? notification : nil);
-        }];
-    }
+void _setNotificationReceivedCallback(NotificationWillShowInForegroundDelegate callback) {
+    [OneSignal setNotificationWillShowInForegroundHandler:^(OSNotification *notification, OSNotificationDisplayResponse completion) {
+        NSString *stringResponse = [notification stringify];
+        bool shouldDisplay = callback([stringResponse UTF8String]);
+        completion(shouldDisplay ? notification : nil);
+    }];
+}
 
-    void _setNotificationOpenedCallback(StringListenerDelegate callback) {
-        [OneSignal setNotificationOpenedHandler:^(OSNotificationOpenedResult * _Nonnull result) {
-            NSString *stringResponse = [result stringify];
-            callback([stringResponse UTF8String]);
-        }];
-    }
+void _setNotificationOpenedCallback(StringListenerDelegate callback) {
+    [OneSignal setNotificationOpenedHandler:^(OSNotificationOpenedResult * _Nonnull result) {
+        NSString *stringResponse = [result stringify];
+        callback([stringResponse UTF8String]);
+    }];
+}
 
-    void _setInAppMessageWillDisplayCallback(StringListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setIamWillDisplayDelegate:callback];
-    }
+void _setInAppMessageWillDisplayCallback(StringListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setIamWillDisplayDelegate:callback];
+}
 
-    void _setInAppMessageDidDisplayCallback(StringListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setIamDidDisplayDelegate:callback];
-    }
+void _setInAppMessageDidDisplayCallback(StringListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setIamDidDisplayDelegate:callback];
+}
 
-    void _setInAppMessageWillDismissCallback(StringListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setIamWillDismissDelegate:callback];
-    }
+void _setInAppMessageWillDismissCallback(StringListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setIamWillDismissDelegate:callback];
+}
 
-    void _setInAppMessageDidDismissCallback(StringListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setIamDidDismissDelegate:callback];
-    }
+void _setInAppMessageDidDismissCallback(StringListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setIamDidDismissDelegate:callback];
+}
 
-    void _setInAppMessageClickedCallback(StringListenerDelegate callback) {
-        [OneSignal setInAppMessageClickHandler:^(OSInAppMessageAction * _Nonnull action) {
-            callback(jsonStringFromDictionary([action jsonRepresentation]));
-        }];
-    }
+void _setInAppMessageClickedCallback(StringListenerDelegate callback) {
+    [OneSignal setInAppMessageClickHandler:^(OSInAppMessageAction * _Nonnull action) {
+        callback(jsonStringFromDictionary([action jsonRepresentation]));
+    }];
+}
 
-    void _setPermissionStateChangedCallback(StateListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setPermissionDelegate:callback];
-    }
+void _setPermissionStateChangedCallback(StateListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setPermissionDelegate:callback];
+}
 
-    void _setSubscriptionStateChangedCallback(StateListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setSubscriptionDelegate:callback];
-    }
+void _setSubscriptionStateChangedCallback(StateListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setSubscriptionDelegate:callback];
+}
 
-    void _setEmailSubscriptionStateChangedCallback(StateListenerDelegate callback) {
-        [[OneSignalObserver sharedObserver] setEmailDelegate:callback];
-    }
+void _setEmailSubscriptionStateChangedCallback(StateListenerDelegate callback) {
+    [[OneSignalObserver sharedObserver] setEmailDelegate:callback];
+}
 
     void _setSMSSubscriptionStateChangedCallback(StateListenerDelegate callback) {
         [[OneSignalObserver sharedObserver] setSmsDelegate:callback];
     }
-
-    void _setPrivacyConsent(bool consent) {
-        [OneSignal consentGranted: consent];
+    
+    const char* _getDeviceState() {
+        auto deviceState = [OneSignal getDeviceState];
+        auto stateStr = jsonStringFromDictionary([deviceState jsonRepresentation]);
+        return strdup(stateStr);
     }
 
-    bool _getPrivacyConsent() {
-        return false; // todo - doesn't exist
-    }
+void _setLogLevel(int logLevel, int alertLevel) {
+    [OneSignal setLogLevel:(ONE_S_LOG_LEVEL) logLevel
+               visualLevel:(ONE_S_LOG_LEVEL) alertLevel];
+}
 
-    void _setRequiresPrivacyConsent(bool required) {
-        [OneSignal setRequiresUserPrivacyConsent: required];
-    }
+void _setPrivacyConsent(bool consent) {
+    [OneSignal consentGranted: consent];
+}
 
-    bool _getRequiresPrivacyConsent() {
-        return [OneSignal requiresUserPrivacyConsent];
-    }
+bool _getPrivacyConsent() {
+    return false; // todo - doesn't exist
+}
 
-    void _initialize(const char* appId) {
-        [OneSignal setAppId:TO_NSSTRING(appId)];
-        [OneSignal initWithLaunchOptions:nil];
-    }
+void _setRequiresPrivacyConsent(bool required) {
+    [OneSignal setRequiresUserPrivacyConsent: required];
+}
 
-    void _promptForPushNotificationsWithUserResponse(int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal promptForPushNotificationsWithUserResponse:^(BOOL accepted) {
-            CALLBACK(accepted);
-        }];
-    }
+bool _getRequiresPrivacyConsent() {
+    return [OneSignal requiresUserPrivacyConsent];
+}
 
-    void _postNotification(const char* optionsJson, int hashCode, StringResponseDelegate callback) {
-        NSDictionary *options = objFromJsonString<NSDictionary*>(optionsJson);
+void _initialize(const char* appId) {
+    [OneSignal setAppId:TO_NSSTRING(appId)];
+    [OneSignal initWithLaunchOptions:nil];
+}
 
-        [OneSignal postNotification:options onSuccess:^(NSDictionary *result) {
-            CALLBACK(jsonStringFromDictionary(result));
-        } onFailure:^(NSError *error) {
-            CALLBACK(NULL);
-        }];
-    }
+void _promptForPushNotificationsWithUserResponse(int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal promptForPushNotificationsWithUserResponse:^(BOOL accepted) {
+        CALLBACK(accepted);
+    }];
+}
 
-    void _setTrigger(const char* key, const char* value) {
-        [OneSignal addTrigger:TO_NSSTRING(key) withValue:TO_NSSTRING(value)];
-    }
+void _postNotification(const char* optionsJson, int hashCode, StringResponseDelegate callback) {
+    NSDictionary *options = objFromJsonString<NSDictionary*>(optionsJson);
 
-    void _setTriggers(const char* triggersJson) {
-        NSDictionary *triggers = objFromJsonString<NSDictionary*>(triggersJson);
-        [OneSignal addTriggers:triggers];
-    }
+    [OneSignal postNotification:options onSuccess:^(NSDictionary *result) {
+        CALLBACK(jsonStringFromDictionary(result));
+    } onFailure:^(NSError *error) {
+        CALLBACK(NULL);
+    }];
+}
 
-    void _removeTrigger(const char* key) {
-        [OneSignal removeTriggerForKey:TO_NSSTRING(key)];
-    }
+void _setTrigger(const char* key, const char* value) {
+    [OneSignal addTrigger:TO_NSSTRING(key) withValue:TO_NSSTRING(value)];
+}
 
-    void _removeTriggers(const char* triggersJson) {
-        NSArray *triggers = objFromJsonString<NSArray*>(triggersJson);
-        [OneSignal removeTriggersForKeys:triggers];
-    }
+void _setTriggers(const char* triggersJson) {
+    NSDictionary *triggers = objFromJsonString<NSDictionary*>(triggersJson);
+    [OneSignal addTriggers:triggers];
+}
 
-    const char* _getTrigger(const char* key) {
-        id value = [OneSignal getTriggerValueForKey:TO_NSSTRING(key)];
-        NSString *asString = [NSString stringWithFormat:@"%@", value];
-        return strdup([asString UTF8String]);
-    }
+void _removeTrigger(const char* key) {
+    [OneSignal removeTriggerForKey:TO_NSSTRING(key)];
+}
 
-    const char* _getTriggers() {
-        NSDictionary *triggers = [OneSignal getTriggers];
-        return strdup(jsonStringFromDictionary(triggers));
-    }
+void _removeTriggers(const char* triggersJson) {
+    NSArray *triggers = objFromJsonString<NSArray*>(triggersJson);
+    [OneSignal removeTriggersForKeys:triggers];
+}
 
-    void _setInAppMessagesArePaused(bool paused) {
-        [OneSignal pauseInAppMessages:paused];
-    }
+const char* _getTrigger(const char* key) {
+    id value = [OneSignal getTriggerValueForKey:TO_NSSTRING(key)];
+    NSString *asString = [NSString stringWithFormat:@"%@", value];
+    return strdup([asString UTF8String]);
+}
 
-    bool _getInAppMessagesArePaused() {
-        return [OneSignal isInAppMessagingPaused];
-    }
+const char* _getTriggers() {
+    NSDictionary *triggers = [OneSignal getTriggers];
+    return strdup(jsonStringFromDictionary(triggers));
+}
 
-    void _sendTag(const char* name, const char* value, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal sendTag:TO_NSSTRING(name)
-                     value:TO_NSSTRING(value)
-                 onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                 onFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
+void _setInAppMessagesArePaused(bool paused) {
+    [OneSignal pauseInAppMessages:paused];
+}
 
-    void _sendTags(const char* tagsJson, int hashCode, BooleanResponseDelegate callback) {
-        NSDictionary *tags = objFromJsonString<NSDictionary*>(tagsJson);
+bool _getInAppMessagesArePaused() {
+    return [OneSignal isInAppMessagingPaused];
+}
 
-        [OneSignal sendTags:tags
-                  onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                  onFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
+void _sendTag(const char* name, const char* value, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal sendTag:TO_NSSTRING(name)
+                 value:TO_NSSTRING(value)
+             onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+             onFailure:^(NSError *error) { CALLBACK(NO); }];
+}
 
-    void _getTags(int hashCode, StringResponseDelegate callback) {
-        [OneSignal getTags:^(NSDictionary *result) {
-            CALLBACK(jsonStringFromDictionary(result));
-        } onFailure:^(NSError *error) {
-            NSLog(@"[Onesignal] Could not get tags");
-            CALLBACK(nil);
-        }];
-    }
+void _sendTags(const char* tagsJson, int hashCode, BooleanResponseDelegate callback) {
+    NSDictionary *tags = objFromJsonString<NSDictionary*>(tagsJson);
 
-    void _deleteTag(const char* name, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal deleteTag:TO_NSSTRING(name)
-                   onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                   onFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
+    [OneSignal sendTags:tags
+              onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+              onFailure:^(NSError *error) { CALLBACK(NO); }];
+}
 
-    void _deleteTags(const char* tagsJson, int hashCode, BooleanResponseDelegate callback) {
-        NSArray *tags = objFromJsonString<NSArray*>(tagsJson);
+void _getTags(int hashCode, StringResponseDelegate callback) {
+    [OneSignal getTags:^(NSDictionary *result) {
+        CALLBACK(jsonStringFromDictionary(result));
+    } onFailure:^(NSError *error) {
+        NSLog(@"[Onesignal] Could not get tags");
+        CALLBACK(nil);
+    }];
+}
 
-        if (tags == nil) {
-            NSLog(@"[Onesignal] Could not parse tags to delete");
-            CALLBACK(NO);
-        }
+void _deleteTag(const char* name, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal deleteTag:TO_NSSTRING(name)
+               onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+               onFailure:^(NSError *error) { CALLBACK(NO); }];
+}
 
-        [OneSignal deleteTags:tags
-                    onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
-                    onFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
+void _deleteTags(const char* tagsJson, int hashCode, BooleanResponseDelegate callback) {
+    NSArray *tags = objFromJsonString<NSArray*>(tagsJson);
 
-    void _setExternalUserId(const char* externalId, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal setExternalUserId:TO_NSSTRING(externalId)
-         withExternalIdAuthHashToken:TO_NSSTRING(authHash)
-                         withSuccess:^(NSDictionary *results) { CALLBACK(YES); }
-                         withFailure:^(NSError *error) { CALLBACK(NO); }];
+    if (tags == nil) {
+        NSLog(@"[Onesignal] Could not parse tags to delete");
+        CALLBACK(NO);
     }
 
-    void _setEmail(const char* email, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal setEmail:TO_NSSTRING(email)
-     withEmailAuthHashToken:TO_NSSTRING(authHash)
-                withSuccess:^{ CALLBACK(YES); }
+    [OneSignal deleteTags:tags
+                onSuccess:^(NSDictionary *result) { CALLBACK(YES); }
+                onFailure:^(NSError *error) { CALLBACK(NO); }];
+}
+
+void _setExternalUserId(const char* externalId, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal setExternalUserId:TO_NSSTRING(externalId)
+     withExternalIdAuthHashToken:TO_NSSTRING(authHash)
+                     withSuccess:^(NSDictionary *results) { CALLBACK(YES); }
+                     withFailure:^(NSError *error) { CALLBACK(NO); }];
+}
+
+void _setEmail(const char* email, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal setEmail:TO_NSSTRING(email)
+ withEmailAuthHashToken:TO_NSSTRING(authHash)
+            withSuccess:^{ CALLBACK(YES); }
+            withFailure:^(NSError *error) { CALLBACK(NO); }];
+}
+
+void _setSMSNumber(const char* smsNumber, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal setSMSNumber:TO_NSSTRING(smsNumber)
+       withSMSAuthHashToken:TO_NSSTRING(authHash)
+                withSuccess:^(NSDictionary *results) { CALLBACK(YES); }
                 withFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
+}
 
-    void _setSMSNumber(const char* smsNumber, const char* authHash, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal setSMSNumber:TO_NSSTRING(smsNumber)
-           withSMSAuthHashToken:TO_NSSTRING(authHash)
-                    withSuccess:^(NSDictionary *results) { CALLBACK(YES); }
-                    withFailure:^(NSError *error) { CALLBACK(NO); }];
-    }
-    
-    void _logoutEmail(int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal logoutEmailWithSuccess:^{ CALLBACK(YES); }
-                              withFailure:^(NSError *error) { CALLBACK(NO); }];
+void _logoutEmail(int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal logoutEmailWithSuccess:^{ CALLBACK(YES); }
+                          withFailure:^(NSError *error) { CALLBACK(NO); }];
+}
+
+void _logoutSMSNumber(int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal logoutSMSNumberWithSuccess:^(NSDictionary *results) { CALLBACK(YES); }
+                                  withFailure:^(NSError *error) { CALLBACK(NO); }];
     }
     
-    void _logoutSMSNumber(int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal logoutSMSNumberWithSuccess:^(NSDictionary *results) { CALLBACK(YES); }
-                                  withFailure:^(NSError *error) { CALLBACK(NO); }];
+    void _setLanguage(const char* languageCode, int hashCode, BooleanResponseDelegate callback) {
+        [OneSignal setLanguage:TO_NSSTRING(languageCode)
+                   withSuccess:^{ CALLBACK(YES); }
+                   withFailure:^(NSError *error) { CALLBACK(NO); }];
     }
 
     void _promptLocation() {
         [OneSignal promptLocation];
     }
 
-    void _setShareLocation(bool share) {
-        [OneSignal setLocationShared:share];
-    }
+void _setShareLocation(bool share) {
+    [OneSignal setLocationShared:share];
+}
 
-    bool _getShareLocation() {
-        return [OneSignal isLocationShared];
-    }
+bool _getShareLocation() {
+    return [OneSignal isLocationShared];
+}
 
-    void _sendOutcome(const char* name, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal sendOutcome:TO_NSSTRING(name)
-                     onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
-    }
+void _sendOutcome(const char* name, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal sendOutcome:TO_NSSTRING(name)
+                 onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
+}
 
-    void _sendUniqueOutcome(const char* name, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal sendUniqueOutcome:TO_NSSTRING(name)
-                           onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
-    }
+void _sendUniqueOutcome(const char* name, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal sendUniqueOutcome:TO_NSSTRING(name)
+                       onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
+}
 
-    void _sendOutcomeWithValue(const char* name, float value, int hashCode, BooleanResponseDelegate callback) {
-        [OneSignal sendOutcomeWithValue:TO_NSSTRING(name)
-                                  value:@(value)
-                              onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
-    }
+void _sendOutcomeWithValue(const char* name, float value, int hashCode, BooleanResponseDelegate callback) {
+    [OneSignal sendOutcomeWithValue:TO_NSSTRING(name)
+                              value:@(value)
+                          onSuccess:^(OSOutcomeEvent *outcome) { CALLBACK(outcome != nil); }];
 }
+}
+
 
- 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.onesignal.unity.ios",
   "displayName": "OneSignal Unity SDK - iOS",
-  "version": "3.0.0-beta.2",
+  "version": "3.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": "3.0.0-beta.2"
+    "com.onesignal.unity.core": "3.0.0-beta.3"
   },
   "keywords": [
     "push-notifications",