Put setting keys into constants and use them

aurimasc · aurimasc · commit 644f1d97067c · 2022-09-02T14:47:22.000+03:00
diff --git a/com.unity.mobile.notifications/Editor/AndroidNotificationPostProcessor.cs b/com.unity.mobile.notifications/Editor/AndroidNotificationPostProcessor.cs
@@ -68,14 +68,14 @@ private void InjectAndroidManifest(string projectPath)
 
             var settings = NotificationSettingsManager.Initialize().AndroidNotificationSettingsFlat;
 
-            var useCustomActivity = (bool)settings.Find(i => i.Key == "UnityNotificationAndroidUseCustomActivity").Value;
+            var useCustomActivity = (bool)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.USE_CUSTOM_ACTIVITY).Value;
             if (useCustomActivity)
             {
-                var customActivity = (string)settings.Find(i => i.Key == "UnityNotificationAndroidCustomActivityString").Value;
+                var customActivity = (string)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.CUSTOM_ACTIVITY_CLASS).Value;
                 AppendAndroidMetadataField(manifestPath, manifestDoc, "custom_notification_android_activity", customActivity);
             }
 
-            var enableRescheduleOnRestart = (bool)settings.Find(i => i.Key == "UnityNotificationAndroidRescheduleOnDeviceRestart").Value;
+            var enableRescheduleOnRestart = (bool)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.RESCHEDULE_ON_RESTART).Value;
             if (enableRescheduleOnRestart)
             {
                 AppendAndroidMetadataField(manifestPath, manifestDoc, "reschedule_notifications_on_restart", "true");
diff --git a/com.unity.mobile.notifications/Editor/NotificationSettings.cs b/com.unity.mobile.notifications/Editor/NotificationSettings.cs
@@ -49,18 +49,22 @@ private static T GetSettingValue<T>(BuildTargetGroup target, string key)
         /// </summary>
         public static class AndroidSettings
         {
+            internal static readonly string RESCHEDULE_ON_RESTART = "UnityNotificationAndroidRescheduleOnDeviceRestart";
+            internal static readonly string USE_CUSTOM_ACTIVITY = "UnityNotificationAndroidUseCustomActivity";
+            internal static readonly string CUSTOM_ACTIVITY_CLASS = "UnityNotificationAndroidCustomActivityString";
+
             /// <summary>
             /// By default AndroidSettings removes all scheduled notifications when the device is restarted. Enable this to automatically reschedule all non expired notifications when the device is turned back on.
             /// </summary>
             public static bool RescheduleOnDeviceRestart
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidRescheduleOnDeviceRestart");
+                    return GetSettingValue<bool>(BuildTargetGroup.Android, RESCHEDULE_ON_RESTART);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidRescheduleOnDeviceRestart", value);
+                    SetSettingValue<bool>(BuildTargetGroup.Android, RESCHEDULE_ON_RESTART, value);
                 }
             }
 
@@ -71,11 +75,11 @@ public static bool UseCustomActivity
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidUseCustomActivity");
+                    return GetSettingValue<bool>(BuildTargetGroup.Android, USE_CUSTOM_ACTIVITY);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidUseCustomActivity", value);
+                    SetSettingValue<bool>(BuildTargetGroup.Android, USE_CUSTOM_ACTIVITY, value);
                 }
             }
 
@@ -86,11 +90,11 @@ public static string CustomActivityString
             {
                 get
                 {
-                    return GetSettingValue<string>(BuildTargetGroup.Android, "UnityNotificationAndroidCustomActivityString");
+                    return GetSettingValue<string>(BuildTargetGroup.Android, CUSTOM_ACTIVITY_CLASS);
                 }
                 set
                 {
-                    SetSettingValue<string>(BuildTargetGroup.Android, "UnityNotificationAndroidCustomActivityString", value);
+                    SetSettingValue<string>(BuildTargetGroup.Android, CUSTOM_ACTIVITY_CLASS, value);
                 }
             }
 
@@ -155,18 +159,26 @@ public static void ClearDrawableResources()
         /// </summary>
         public static class iOSSettings
         {
+            internal static readonly string REQUEST_AUTH_ON_LAUNCH = "UnityNotificationRequestAuthorizationOnAppLaunch";
+            internal static readonly string DEFAULT_AUTH_OPTS = "UnityNotificationDefaultAuthorizationOptions";
+            internal static readonly string ADD_PUSH_CAPABILITY = "UnityAddRemoteNotificationCapability";
+            internal static readonly string REQUEST_PUSH_AUTH_ON_LAUNCH = "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch";
+            internal static readonly string PUSH_NOTIFICATION_PRESENTATION = "UnityRemoteNotificationForegroundPresentationOptions";
+            internal static readonly string USE_APS_RELEASE = "UnityUseAPSReleaseEnvironment";
+            internal static readonly string USE_LOCATION_TRIGGER = "UnityUseLocationNotificationTrigger";
+
             /// <summary>
             /// It's recommended to make the authorization request during the app's launch cycle. If this is enabled the user will be shown the authorization pop-up immediately when the app launches. If it’s unchecked you’ll need to manually create an AuthorizationRequest before your app can send or receive notifications.
             /// </summary>
             public static bool RequestAuthorizationOnAppLaunch
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationOnAppLaunch");
+                    return GetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_AUTH_ON_LAUNCH);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationOnAppLaunch", value);
+                    SetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_AUTH_ON_LAUNCH, value);
                 }
             }
 
@@ -177,11 +189,11 @@ public static AuthorizationOption DefaultAuthorizationOptions
             {
                 get
                 {
-                    return GetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, "UnityNotificationDefaultAuthorizationOptions");
+                    return GetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, DEFAULT_AUTH_OPTS);
                 }
                 set
                 {
-                    SetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, "UnityNotificationDefaultAuthorizationOptions", value);
+                    SetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, DEFAULT_AUTH_OPTS, value);
                 }
             }
 
@@ -192,11 +204,11 @@ public static bool AddRemoteNotificationCapability
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityAddRemoteNotificationCapability");
+                    return GetSettingValue<bool>(BuildTargetGroup.iOS, ADD_PUSH_CAPABILITY);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityAddRemoteNotificationCapability", value);
+                    SetSettingValue<bool>(BuildTargetGroup.iOS, ADD_PUSH_CAPABILITY, value);
                 }
             }
 
@@ -207,11 +219,11 @@ public static bool NotificationRequestAuthorizationForRemoteNotificationsOnAppLa
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch");
+                    return GetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_PUSH_AUTH_ON_LAUNCH);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch", value);
+                    SetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_PUSH_AUTH_ON_LAUNCH, value);
                 }
             }
 
@@ -222,11 +234,11 @@ public static PresentationOption RemoteNotificationForegroundPresentationOptions
             {
                 get
                 {
-                    return GetSettingValue<PresentationOption>(BuildTargetGroup.iOS, "UnityRemoteNotificationForegroundPresentationOptions");
+                    return GetSettingValue<PresentationOption>(BuildTargetGroup.iOS, PUSH_NOTIFICATION_PRESENTATION);
                 }
                 set
                 {
-                    SetSettingValue<PresentationOption>(BuildTargetGroup.iOS, "UnityRemoteNotificationForegroundPresentationOptions", value);
+                    SetSettingValue<PresentationOption>(BuildTargetGroup.iOS, PUSH_NOTIFICATION_PRESENTATION, value);
                 }
             }
 
@@ -237,11 +249,11 @@ public static bool UseAPSReleaseEnvironment
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseAPSReleaseEnvironment");
+                    return GetSettingValue<bool>(BuildTargetGroup.iOS, USE_APS_RELEASE);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseAPSReleaseEnvironment", value);
+                    SetSettingValue<bool>(BuildTargetGroup.iOS, USE_APS_RELEASE, value);
                 }
             }
 
@@ -252,11 +264,11 @@ public static bool UseLocationNotificationTrigger
             {
                 get
                 {
-                    return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseLocationNotificationTrigger");
+                    return GetSettingValue<bool>(BuildTargetGroup.iOS, USE_LOCATION_TRIGGER);
                 }
                 set
                 {
-                    SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseLocationNotificationTrigger", value);
+                    SetSettingValue<bool>(BuildTargetGroup.iOS, USE_LOCATION_TRIGGER, value);
                 }
             }
         }
diff --git a/com.unity.mobile.notifications/Editor/NotificationSettingsManager.cs b/com.unity.mobile.notifications/Editor/NotificationSettingsManager.cs
@@ -102,70 +102,70 @@ public static NotificationSettingsManager Initialize()
             settingsManager.iOSNotificationSettings = new List<NotificationSetting>()
             {
                 new NotificationSetting(
-                    "UnityNotificationRequestAuthorizationOnAppLaunch",
+                    NotificationSettings.iOSSettings.REQUEST_AUTH_ON_LAUNCH,
                     "Request Authorization on App Launch",
                     "It's recommended to make the authorization request during the app's launch cycle. If this is enabled the authorization pop-up will show up immediately during launching. Otherwise you need to manually create an AuthorizationRequest before sending or receiving notifications.",
-                    settingsManager.GetOrAddNotificationSettingValue("UnityNotificationRequestAuthorizationOnAppLaunch", true, false),
+                    settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.REQUEST_AUTH_ON_LAUNCH, true, false),
                     dependencies: new List<NotificationSetting>()
                     {
                         new NotificationSetting(
-                            "UnityNotificationDefaultAuthorizationOptions",
+                            NotificationSettings.iOSSettings.DEFAULT_AUTH_OPTS,
                             "Default Notification Authorization Options",
                             "Configure the notification interaction types which will be included in the authorization request if \"Request Authorization on App Launch\" is enabled.",
-                            settingsManager.GetOrAddNotificationSettingValue("UnityNotificationDefaultAuthorizationOptions",
+                            settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.DEFAULT_AUTH_OPTS,
                                 AuthorizationOption.Alert | AuthorizationOption.Badge | AuthorizationOption.Sound, false)),
                     }),
                 new NotificationSetting(
-                    "UnityAddRemoteNotificationCapability",
+                    NotificationSettings.iOSSettings.ADD_PUSH_CAPABILITY,
                     "Enable Push Notifications",
                     "Enable this to add the push notification capability to the Xcode project, also to retrieve the device token from an AuthorizationRequest.",
-                    settingsManager.GetOrAddNotificationSettingValue("UnityAddRemoteNotificationCapability", false, false),
+                    settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.ADD_PUSH_CAPABILITY, false, false),
                     false,
                     new List<NotificationSetting>()
                     {
                         new NotificationSetting(
-                            "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch",
+                            NotificationSettings.iOSSettings.REQUEST_PUSH_AUTH_ON_LAUNCH,
                             "Register for Push Notifications on App Launch",
                             "Enable this to automatically register your app with APNs after launching to receive remote notifications. You need to manually create an AuthorizationRequest to get the device token.",
-                            settingsManager.GetOrAddNotificationSettingValue("UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch", false, false)),
+                            settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.REQUEST_PUSH_AUTH_ON_LAUNCH, false, false)),
                         new NotificationSetting(
-                            "UnityRemoteNotificationForegroundPresentationOptions",
+                            NotificationSettings.iOSSettings.PUSH_NOTIFICATION_PRESENTATION,
                             "Remote Notification Foreground Presentation Options",
                             "Configure the default presentation options for received remote notifications. In order to use the specified presentation options, your app must have received the authorization (the user might change it at any time).",
-                            settingsManager.GetOrAddNotificationSettingValue("UnityRemoteNotificationForegroundPresentationOptions", (PresentationOption)iOSPresentationOption.All, false)),
-                        new NotificationSetting("UnityUseAPSReleaseEnvironment",
+                            settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.PUSH_NOTIFICATION_PRESENTATION, (PresentationOption)iOSPresentationOption.All, false)),
+                        new NotificationSetting(NotificationSettings.iOSSettings.USE_APS_RELEASE,
                             "Enable Release Environment for APS",
                             "Enable this when signing the app with a production certificate.",
-                            settingsManager.GetOrAddNotificationSettingValue("UnityUseAPSReleaseEnvironment", false, false),
+                            settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.USE_APS_RELEASE, false, false),
                             false),
                     }),
-                new NotificationSetting("UnityUseLocationNotificationTrigger",
+                new NotificationSetting(NotificationSettings.iOSSettings.USE_LOCATION_TRIGGER,
                     "Include CoreLocation Framework",
                     "Include the CoreLocation framework to use the iOSNotificationLocationTrigger in your project.",
-                    settingsManager.GetOrAddNotificationSettingValue("UnityUseLocationNotificationTrigger", false, false),
+                    settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.iOSSettings.USE_LOCATION_TRIGGER, false, false),
                     false)
             };
 
             // Create the settings for Android.
             settingsManager.AndroidNotificationSettings = new List<NotificationSetting>()
             {
                 new NotificationSetting(
-                    "UnityNotificationAndroidRescheduleOnDeviceRestart",
+                    NotificationSettings.AndroidSettings.RESCHEDULE_ON_RESTART,
                     "Reschedule on Device Restart",
                     "Enable this to automatically reschedule all non-expired notifications after device restart. By default AndroidSettings removes all scheduled notifications after restarting.",
-                    settingsManager.GetOrAddNotificationSettingValue("UnityNotificationAndroidRescheduleOnDeviceRestart", false, true)),
+                    settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.AndroidSettings.RESCHEDULE_ON_RESTART, false, true)),
                 new NotificationSetting(
-                    "UnityNotificationAndroidUseCustomActivity",
+                    NotificationSettings.AndroidSettings.USE_CUSTOM_ACTIVITY,
                     "Use Custom Activity",
                     "Enable this to override the activity which will be opened when the user taps the notification.",
-                    settingsManager.GetOrAddNotificationSettingValue("UnityNotificationAndroidUseCustomActivity", false, true),
+                    settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.AndroidSettings.USE_CUSTOM_ACTIVITY, false, true),
                     dependencies: new List<NotificationSetting>()
                     {
                         new NotificationSetting(
-                            "UnityNotificationAndroidCustomActivityString",
+                            NotificationSettings.AndroidSettings.CUSTOM_ACTIVITY_CLASS,
                             "Custom Activity Name",
                             "The full class name of the activity which will be assigned to the notification.",
-                            settingsManager.GetOrAddNotificationSettingValue("UnityNotificationAndroidCustomActivityString", "com.unity3d.player.UnityPlayerActivity", true))
+                            settingsManager.GetOrAddNotificationSettingValue(NotificationSettings.AndroidSettings.CUSTOM_ACTIVITY_CLASS, "com.unity3d.player.UnityPlayerActivity", true))
                     })
             };
 
diff --git a/com.unity.mobile.notifications/Editor/iOSNotificationPostProcessor.cs b/com.unity.mobile.notifications/Editor/iOSNotificationPostProcessor.cs
@@ -35,13 +35,13 @@ public static void OnPostprocessBuild(BuildTarget buildTarget, string path)
 
         var settings = NotificationSettingsManager.Initialize().iOSNotificationSettingsFlat;
 
-        var needLocationFramework = (bool)settings.Find(i => i.Key == "UnityUseLocationNotificationTrigger").Value;
-        var addPushNotificationCapability = (bool)settings.Find(i => i.Key == "UnityAddRemoteNotificationCapability").Value;
+        var needLocationFramework = (bool)settings.Find(i => i.Key == NotificationSettings.iOSSettings.USE_LOCATION_TRIGGER).Value;
+        var addPushNotificationCapability = (bool)settings.Find(i => i.Key == NotificationSettings.iOSSettings.ADD_PUSH_CAPABILITY).Value;
 
         var useReleaseAPSEnv = false;
         if (addPushNotificationCapability)
         {
-            var useReleaseAPSEnvSetting = settings.Find(i => i.Key == "UnityUseAPSReleaseEnvironment");
+            var useReleaseAPSEnvSetting = settings.Find(i => i.Key == NotificationSettings.iOSSettings.USE_APS_RELEASE);
             if (useReleaseAPSEnvSetting != null)
                 useReleaseAPSEnv = (bool)useReleaseAPSEnvSetting.Value;
         }

Original file line number	Diff line number	Diff line change
`@@ -68,14 +68,14 @@ private void InjectAndroidManifest(string projectPath)`
`68`	`68`
`69`	`69`	`var settings = NotificationSettingsManager.Initialize().AndroidNotificationSettingsFlat;`
`70`	`70`
`71`		`- var useCustomActivity = (bool)settings.Find(i => i.Key == "UnityNotificationAndroidUseCustomActivity").Value;`
	`71`	`+ var useCustomActivity = (bool)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.USE_CUSTOM_ACTIVITY).Value;`
`72`	`72`	`if (useCustomActivity)`
`73`	`73`	`{`
`74`		`- var customActivity = (string)settings.Find(i => i.Key == "UnityNotificationAndroidCustomActivityString").Value;`
	`74`	`+ var customActivity = (string)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.CUSTOM_ACTIVITY_CLASS).Value;`
`75`	`75`	`AppendAndroidMetadataField(manifestPath, manifestDoc, "custom_notification_android_activity", customActivity);`
`76`	`76`	`}`
`77`	`77`
`78`		`- var enableRescheduleOnRestart = (bool)settings.Find(i => i.Key == "UnityNotificationAndroidRescheduleOnDeviceRestart").Value;`
	`78`	`+ var enableRescheduleOnRestart = (bool)settings.Find(i => i.Key == NotificationSettings.AndroidSettings.RESCHEDULE_ON_RESTART).Value;`
`79`	`79`	`if (enableRescheduleOnRestart)`
`80`	`80`	`{`
`81`	`81`	`AppendAndroidMetadataField(manifestPath, manifestDoc, "reschedule_notifications_on_restart", "true");`
Original file line number	Diff line number	Diff line change
`@@ -49,18 +49,22 @@ private static T GetSettingValue<T>(BuildTargetGroup target, string key)`
`49`	`49`	`/// </summary>`
`50`	`50`	`public static class AndroidSettings`
`51`	`51`	`{`
	`52`	`+ internal static readonly string RESCHEDULE_ON_RESTART = "UnityNotificationAndroidRescheduleOnDeviceRestart";`
	`53`	`+ internal static readonly string USE_CUSTOM_ACTIVITY = "UnityNotificationAndroidUseCustomActivity";`
	`54`	`+ internal static readonly string CUSTOM_ACTIVITY_CLASS = "UnityNotificationAndroidCustomActivityString";`
	`55`	`+`
`52`	`56`	`/// <summary>`
`53`	`57`	`/// By default AndroidSettings removes all scheduled notifications when the device is restarted. Enable this to automatically reschedule all non expired notifications when the device is turned back on.`
`54`	`58`	`/// </summary>`
`55`	`59`	`public static bool RescheduleOnDeviceRestart`
`56`	`60`	`{`
`57`	`61`	`get`
`58`	`62`	`{`
`59`		`- return GetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidRescheduleOnDeviceRestart");`
	`63`	`+ return GetSettingValue<bool>(BuildTargetGroup.Android, RESCHEDULE_ON_RESTART);`
`60`	`64`	`}`
`61`	`65`	`set`
`62`	`66`	`{`
`63`		`- SetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidRescheduleOnDeviceRestart", value);`
	`67`	`+ SetSettingValue<bool>(BuildTargetGroup.Android, RESCHEDULE_ON_RESTART, value);`
`64`	`68`	`}`
`65`	`69`	`}`
`66`	`70`
`@@ -71,11 +75,11 @@ public static bool UseCustomActivity`
`71`	`75`	`{`
`72`	`76`	`get`
`73`	`77`	`{`
`74`		`- return GetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidUseCustomActivity");`
	`78`	`+ return GetSettingValue<bool>(BuildTargetGroup.Android, USE_CUSTOM_ACTIVITY);`
`75`	`79`	`}`
`76`	`80`	`set`
`77`	`81`	`{`
`78`		`- SetSettingValue<bool>(BuildTargetGroup.Android, "UnityNotificationAndroidUseCustomActivity", value);`
	`82`	`+ SetSettingValue<bool>(BuildTargetGroup.Android, USE_CUSTOM_ACTIVITY, value);`
`79`	`83`	`}`
`80`	`84`	`}`
`81`	`85`
`@@ -86,11 +90,11 @@ public static string CustomActivityString`
`86`	`90`	`{`
`87`	`91`	`get`
`88`	`92`	`{`
`89`		`- return GetSettingValue<string>(BuildTargetGroup.Android, "UnityNotificationAndroidCustomActivityString");`
	`93`	`+ return GetSettingValue<string>(BuildTargetGroup.Android, CUSTOM_ACTIVITY_CLASS);`
`90`	`94`	`}`
`91`	`95`	`set`
`92`	`96`	`{`
`93`		`- SetSettingValue<string>(BuildTargetGroup.Android, "UnityNotificationAndroidCustomActivityString", value);`
	`97`	`+ SetSettingValue<string>(BuildTargetGroup.Android, CUSTOM_ACTIVITY_CLASS, value);`
`94`	`98`	`}`
`95`	`99`	`}`
`96`	`100`
`@@ -155,18 +159,26 @@ public static void ClearDrawableResources()`
`155`	`159`	`/// </summary>`
`156`	`160`	`public static class iOSSettings`
`157`	`161`	`{`
	`162`	`+ internal static readonly string REQUEST_AUTH_ON_LAUNCH = "UnityNotificationRequestAuthorizationOnAppLaunch";`
	`163`	`+ internal static readonly string DEFAULT_AUTH_OPTS = "UnityNotificationDefaultAuthorizationOptions";`
	`164`	`+ internal static readonly string ADD_PUSH_CAPABILITY = "UnityAddRemoteNotificationCapability";`
	`165`	`+ internal static readonly string REQUEST_PUSH_AUTH_ON_LAUNCH = "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch";`
	`166`	`+ internal static readonly string PUSH_NOTIFICATION_PRESENTATION = "UnityRemoteNotificationForegroundPresentationOptions";`
	`167`	`+ internal static readonly string USE_APS_RELEASE = "UnityUseAPSReleaseEnvironment";`
	`168`	`+ internal static readonly string USE_LOCATION_TRIGGER = "UnityUseLocationNotificationTrigger";`
	`169`	`+`
`158`	`170`	`/// <summary>`
`159`	`171`	`/// It's recommended to make the authorization request during the app's launch cycle. If this is enabled the user will be shown the authorization pop-up immediately when the app launches. If it’s unchecked you’ll need to manually create an AuthorizationRequest before your app can send or receive notifications.`
`160`	`172`	`/// </summary>`
`161`	`173`	`public static bool RequestAuthorizationOnAppLaunch`
`162`	`174`	`{`
`163`	`175`	`get`
`164`	`176`	`{`
`165`		`- return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationOnAppLaunch");`
	`177`	`+ return GetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_AUTH_ON_LAUNCH);`
`166`	`178`	`}`
`167`	`179`	`set`
`168`	`180`	`{`
`169`		`- SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationOnAppLaunch", value);`
	`181`	`+ SetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_AUTH_ON_LAUNCH, value);`
`170`	`182`	`}`
`171`	`183`	`}`
`172`	`184`
`@@ -177,11 +189,11 @@ public static AuthorizationOption DefaultAuthorizationOptions`
`177`	`189`	`{`
`178`	`190`	`get`
`179`	`191`	`{`
`180`		`- return GetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, "UnityNotificationDefaultAuthorizationOptions");`
	`192`	`+ return GetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, DEFAULT_AUTH_OPTS);`
`181`	`193`	`}`
`182`	`194`	`set`
`183`	`195`	`{`
`184`		`- SetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, "UnityNotificationDefaultAuthorizationOptions", value);`
	`196`	`+ SetSettingValue<AuthorizationOption>(BuildTargetGroup.iOS, DEFAULT_AUTH_OPTS, value);`
`185`	`197`	`}`
`186`	`198`	`}`
`187`	`199`
`@@ -192,11 +204,11 @@ public static bool AddRemoteNotificationCapability`
`192`	`204`	`{`
`193`	`205`	`get`
`194`	`206`	`{`
`195`		`- return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityAddRemoteNotificationCapability");`
	`207`	`+ return GetSettingValue<bool>(BuildTargetGroup.iOS, ADD_PUSH_CAPABILITY);`
`196`	`208`	`}`
`197`	`209`	`set`
`198`	`210`	`{`
`199`		`- SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityAddRemoteNotificationCapability", value);`
	`211`	`+ SetSettingValue<bool>(BuildTargetGroup.iOS, ADD_PUSH_CAPABILITY, value);`
`200`	`212`	`}`
`201`	`213`	`}`
`202`	`214`
`@@ -207,11 +219,11 @@ public static bool NotificationRequestAuthorizationForRemoteNotificationsOnAppLa`
`207`	`219`	`{`
`208`	`220`	`get`
`209`	`221`	`{`
`210`		`- return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch");`
	`222`	`+ return GetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_PUSH_AUTH_ON_LAUNCH);`
`211`	`223`	`}`
`212`	`224`	`set`
`213`	`225`	`{`
`214`		`- SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityNotificationRequestAuthorizationForRemoteNotificationsOnAppLaunch", value);`
	`226`	`+ SetSettingValue<bool>(BuildTargetGroup.iOS, REQUEST_PUSH_AUTH_ON_LAUNCH, value);`
`215`	`227`	`}`
`216`	`228`	`}`
`217`	`229`
`@@ -222,11 +234,11 @@ public static PresentationOption RemoteNotificationForegroundPresentationOptions`
`222`	`234`	`{`
`223`	`235`	`get`
`224`	`236`	`{`
`225`		`- return GetSettingValue<PresentationOption>(BuildTargetGroup.iOS, "UnityRemoteNotificationForegroundPresentationOptions");`
	`237`	`+ return GetSettingValue<PresentationOption>(BuildTargetGroup.iOS, PUSH_NOTIFICATION_PRESENTATION);`
`226`	`238`	`}`
`227`	`239`	`set`
`228`	`240`	`{`
`229`		`- SetSettingValue<PresentationOption>(BuildTargetGroup.iOS, "UnityRemoteNotificationForegroundPresentationOptions", value);`
	`241`	`+ SetSettingValue<PresentationOption>(BuildTargetGroup.iOS, PUSH_NOTIFICATION_PRESENTATION, value);`
`230`	`242`	`}`
`231`	`243`	`}`
`232`	`244`
`@@ -237,11 +249,11 @@ public static bool UseAPSReleaseEnvironment`
`237`	`249`	`{`
`238`	`250`	`get`
`239`	`251`	`{`
`240`		`- return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseAPSReleaseEnvironment");`
	`252`	`+ return GetSettingValue<bool>(BuildTargetGroup.iOS, USE_APS_RELEASE);`
`241`	`253`	`}`
`242`	`254`	`set`
`243`	`255`	`{`
`244`		`- SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseAPSReleaseEnvironment", value);`
	`256`	`+ SetSettingValue<bool>(BuildTargetGroup.iOS, USE_APS_RELEASE, value);`
`245`	`257`	`}`
`246`	`258`	`}`
`247`	`259`
`@@ -252,11 +264,11 @@ public static bool UseLocationNotificationTrigger`
`252`	`264`	`{`
`253`	`265`	`get`
`254`	`266`	`{`
`255`		`- return GetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseLocationNotificationTrigger");`
	`267`	`+ return GetSettingValue<bool>(BuildTargetGroup.iOS, USE_LOCATION_TRIGGER);`
`256`	`268`	`}`
`257`	`269`	`set`
`258`	`270`	`{`
`259`		`- SetSettingValue<bool>(BuildTargetGroup.iOS, "UnityUseLocationNotificationTrigger", value);`
	`271`	`+ SetSettingValue<bool>(BuildTargetGroup.iOS, USE_LOCATION_TRIGGER, value);`
`260`	`272`	`}`
`261`	`273`	`}`
`262`	`274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,13 +35,13 @@ public static void OnPostprocessBuild(BuildTarget buildTarget, string path)`
`35`	`35`
`36`	`36`	`var settings = NotificationSettingsManager.Initialize().iOSNotificationSettingsFlat;`
`37`	`37`
`38`		`- var needLocationFramework = (bool)settings.Find(i => i.Key == "UnityUseLocationNotificationTrigger").Value;`
`39`		`- var addPushNotificationCapability = (bool)settings.Find(i => i.Key == "UnityAddRemoteNotificationCapability").Value;`
	`38`	`+ var needLocationFramework = (bool)settings.Find(i => i.Key == NotificationSettings.iOSSettings.USE_LOCATION_TRIGGER).Value;`
	`39`	`+ var addPushNotificationCapability = (bool)settings.Find(i => i.Key == NotificationSettings.iOSSettings.ADD_PUSH_CAPABILITY).Value;`
`40`	`40`
`41`	`41`	`var useReleaseAPSEnv = false;`
`42`	`42`	`if (addPushNotificationCapability)`
`43`	`43`	`{`
`44`		`- var useReleaseAPSEnvSetting = settings.Find(i => i.Key == "UnityUseAPSReleaseEnvironment");`
	`44`	`+ var useReleaseAPSEnvSetting = settings.Find(i => i.Key == NotificationSettings.iOSSettings.USE_APS_RELEASE);`
`45`	`45`	`if (useReleaseAPSEnvSetting != null)`
`46`	`46`	`useReleaseAPSEnv = (bool)useReleaseAPSEnvSetting.Value;`
`47`	`47`	`}`