{"id":89582,"date":"2021-01-19T15:58:21","date_gmt":"2021-01-19T15:58:21","guid":{"rendered":"https:\/\/www.red-gate.com\/simple-talk\/?p=89582"},"modified":"2022-04-24T20:58:56","modified_gmt":"2022-04-24T20:58:56","slug":"how-to-use-unitys-remote-config","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/how-to-use-unitys-remote-config\/","title":{"rendered":"How to use Unity’s Remote Config"},"content":{"rendered":"

Imagine you’ve spent much time, possibly years, into crafting your Unity app. The app then gets published, the launch is smooth, everything’s good. However, then some time passes, and you want to modify some small item in your app. Maybe it’s a game, and you want to change the base health of an enemy type, or it’s a business app, and you want to notify users of a handy new feature. One might expect the developer to open up their Unity project, whether at home or at a work PC, make the necessary tweaks, and push these changes to their app. However, suppose instead you’re out of town, away from your work PC, and the changes required need to happen as soon as possible. What do you do? One option available is Unity’s Remote Config, a feature that lets you make changes to an app from anywhere in the world so long as you have a web browser and can open your Unity Dashboard.<\/p>\n

Unity\u2019s Remote Config lets you change your app remotely and in real-time. It’s especially useful for fine-tuning your software attributes without needing to redeploy it with every change. You can also use Remote Config for live events by enabling holiday themed content or to unlock a previously created feature. Note that Remote Config is not meant to be used for creating entirely new content for your app, but rather modifying or unlocking what is already in the app. While actively developing the application, Remote Config can be used to iterate on the program without needing to modify the code itself. To demonstrate this feature, a simple project will be put together that allows you to change a bool, string, int, and even JSON data from within the Unity Dashboard. Changes made in the dashboard will then be reflected within the app itself.<\/p>\n

Project Setup<\/h2>\n

This example assumes that Unity 2020 will be used for the project. However, the 2019 version will work just as well. Select the default 3D template, give your project a name, and set its location. Then click the Create <\/em>button.<\/p>\n

\"CreatingFigure 1: Creating a new project<\/strong><\/p>\n

To utilize Unity\u2019s Remote Config, you must set up Unity services and acquire a project ID. To do this, navigate to the Edit <\/em>top menu and select Project Settings<\/em>. From there, select the Services <\/em>option. Please note that you may need to create a Unity account and log into it at this point. You’ll then be asked to select an organization. Once you do, you may then click the Create project ID <\/em>button. Unity will then automatically assign your project an ID.<\/p>\n

\"Setting<\/p>\n

Figure 2: Setting up Unity Services<\/strong><\/p>\n

Next, you need to install the Remote Config package from Unity. Doing this requires navigating to the Package Manager<\/em>, which is found in the top menu under Window->Package Manager<\/em>. At first, the Package Manager <\/em>will only show the packages currently installed in your project. To view all available packages, select the dropdown that currently shows Packages: In Project <\/em>and choose Unity Registry<\/em>.<\/p>\n

\"Accessing<\/p>\n

Figure 3: Accessing packages in the Unity Registry<\/strong><\/p>\n

Scroll down until you find Remote Config<\/em>, then click the Install <\/em>button to add Remote Config to your project.<\/p>\n

\"InstallingFigure 4: Installing the Remote Config package<\/strong><\/p>\n

To better see the effects of Remote Config, you’ll need a small handful of objects to change within your app. Start by creating a simple cube by going to the Hierarchy <\/em>window and selecting the + <\/em>button, then choosing 3D Object->Cube<\/em>.<\/p>\n

\"Creating<\/p>\n

Figure 5: Creating a new object<\/strong><\/p>\n

By default, the object should be placed with location coordinates of 0, 0, 0 with no rotation and a scale of one. You can leave this object as is, but if you want or need to change it, go into the Inspector <\/em>window and change the values seen in the Transform <\/em>component. Right after that, using the same object creation menu, create a UI with text. Set its position to be 0, 150 and give it a width of 250. It also looks nice to give the text center alignment and some default text. Finally, give it a unique name to help identify it easier.<\/p>\n

\"Giving<\/p>\n

Figure 6: Giving object a name, setting position and size, creating default text, and alignment<\/strong><\/p>\n

Duplicate this text with Ctrl + D and move the copy a little lower down (this example changed the Y position to 100). This text will display a lucky number, which it will get from the Remote Config server. Change the object’s name and default text accordingly.<\/p>\n

Finally, create the script needed to get the project running. Inside your Assets <\/em>window, right-click and select Create->C# Script<\/em>. The script in the example will be called GetConfig<\/em>. With this, all the assets are in place, but Remote Config itself still needs a little more setup before you begin the coding process.<\/p>\n

\"Creating<\/p>\n

Figure 7: Creating a new C# script<\/strong><\/p>\n

Preparing Remote Config<\/em><\/strong><\/p>\n

From the top menu, select Window->Remote Config<\/em>. Once you do so, you’ll be greeted with a window where you can create settings and push settings from Unity to the Remote Config server and vice versa. First, you’ll need some environments to work in. You should be able to pull in the two default environments currently sitting in the server. Doing this is as simple as clicking the Pull <\/em>button in the top right. If these environments don’t appear, wait a few minutes for Unity to automatically create these in the server, then try pulling again. There’s also the option of creating your own environment if you are having trouble pulling the default environments. The Create <\/em>button at the top of the window will allow you to do this. If you aren’t able to create an environment within the Remote Config window or can’t find the Create <\/em>button, try updating to a preview version of Remote Config. Directions on how to do this are listed in the JSON portion of this article. . . As far as what environment to use, , it’s recommended to use or create the Development <\/em>environment while actively developing the app.<\/p>\n

Now is the time to create some settings that will be used in the project and can change from within your Unity Dashboard. Click the Add Settings <\/em>button located at the bottom. A new setting is created with the option to give it a name and choose a type. This project will focus on editing a bool, string, and int value. After choosing a type, you’ll then be asked for a value. Give the setting a value of your choosing.<\/p>\n

\"The<\/p>\n

Figure 8: The Remote Config window with settings<\/strong><\/p>\n

In order to properly utilize Remote Config, you’ll need to push these settings out to the server. Click the Push <\/em>button to achieve this. Once you’ve done so, you’ll have successfully stored these values in the Remote Config server to be used in your project. In the future, if you ever needed to get any new or updated settings made in the Unity Dashboard, you would click the Pull <\/em>button. So, Push <\/em>any settings you make in the editor, Pull <\/em>any made in the dashboard.<\/p>\n

Since this app wants to use settings in the Development <\/em>environment within the Remote Config server, you’ll need to go to your project’s Build Settings <\/em>in the File <\/em>menu and check the box that says Development Build<\/em>. This change can be made by first going to the top menu, choosing File<\/em>, then Build Settings<\/em>, then ticking Development Build<\/em>. Now, whenever you run a .exe build of the app, it will get the settings seen in the Development <\/em>environment. When releasing an app, you would want to uncheck Development Build <\/em>and have your settings created and ready within the Release <\/em>environment.<\/p>\n

GetConfig Code<\/h2>\n

With everything set up, open the GetConfig <\/em>script by double-clicking it in the Assets <\/em>window. Once Visual Studio opens, the first thing to do is add using Unity.RemoteConfig<\/code> and using UnityEngine.UI <\/code>to the top of the script. Once that’s done, add the following to the class:<\/p>\n

public struct userAttributes { }\r\npublic struct appAttributes { }\r\nprivate bool isBlue;\r\nprivate string message;\r\nprivate int number;\r\n[SerializeField] private Renderer rend;\r\n[SerializeField] private Text messageText;\r\n[SerializeField] private Text numberText;<\/pre>\n
For now, these two structs are not going to do anything. They will simply be passed into a method later to tell Unity to just use the default Remote Config settings. If you wanted to add custom attributes like a player name or skill level, this is where you would set that up. From there, your custom attributes can be used to only apply settings to users with certain attributes. However, for this project, the code will be kept simpler and focus on important aspects of Unity\u2019s Remote Config.<\/p>\n
Three private variables isBlue<\/code>, <\/em>message<\/code>, <\/em>and number<\/code> will all be changed based on the values stored within your Remote Config settings. These values will be displayed using the cube object and the UI. All remaining variables are for changing properties of object components and the UI text created earlier. The SerializeField<\/code> tag makes these otherwise private variables visible to the editor for editing.<\/p>\n
The first thing to do is to let Unity know to call the SetValues<\/code> function once Remote Config has finished retrieving data. SetValues<\/code> will be created in a moment. After that, it then works on retrieving your currently stored configuration. Notice that the userAttributes<\/code> and appAttributes<\/code> types are passed into the FetchConfigs<\/code> method, followed by creating new instances of those structs. All this is saying is that the project will use the default settings currently stored in Remote Config. This will all happen within the Awake<\/code> function which replaces the Start<\/code> function. Unity’s Awake<\/code> function grants a little more safety when using Remote Config.<\/p>\n
private void Awake()\r\n{\r\n\tConfigManager.FetchCompleted += SetValues;\r\n\tConfigManager.FetchConfigs<userAttributes, appAttributes>\r\n             (new userAttributes(), new appAttributes());\r\n}<\/pre>\n
Next comes the Update<\/code> function, which will have been created automatically when creating the script. Very little Remote Config work is being done here. This function will let you fetch configurations again whenever the left mouse button is clicked and give the app a way to close itself using the escape key. The code will be especially useful in demonstrating how you can make changes to your app from the Unity dashboard seamlessly while it is running.<\/p>\n
private void Update()\r\n{\r\n\tif (Input.GetMouseButtonDown(0))\r\n\t\tConfigManager.FetchConfigs<userAttributes, appAttributes>(\r\n                      new userAttributes(), new appAttributes());\r\n\tif (Input.GetKeyDown(KeyCode.Escape))\r\n\t\tApplication.Quit();\r\n}<\/pre>\n
Now is where the SetValues<\/code> method comes in and is where the magic happens. Using Remote Config, you’ll change the values of isBlue<\/code>, <\/em>message<\/code>, <\/em>and number<\/code> then use those values to change different parts of the app. The cube object will change color based on the value of isBlue<\/code>, and the values of message<\/code> and number<\/code> will be shown in the app’s UI.<\/p>\n
void SetValues(ConfigResponse response)\r\n{\r\n\tisBlue = ConfigManager.appConfig.GetBool(\"IsBlue\");\r\n     message = ConfigManager.appConfig.GetString(\"MessageOfTheDay\");\r\n     number = ConfigManager.appConfig.GetInt(\"LuckyNumber\");\r\n\t\/\/ apply values pulled from config\r\n\tif (isBlue)\r\n\t\trend.material.color = new Color(0, 0, 1);\r\n\telse\r\n\t\trend.material.color = new Color(1, 0, 0);\r\n\tmessageText.text = message;\r\n\tnumberText.text = \"Lucky Number is: \" + number.ToString();\r\n}<\/pre>\n
The last job to be done is to make sure SetValues<\/code> won’t be called when the object is destroyed. Earlier in the Awake<\/code> function the script tells Unity to call SetValues<\/code> anytime Remote Config has finished gathering configurations. However, if the object using Remote Config’s data is destroyed, you wouldn’t want that function being called. So, as a precaution, OnDestroy<\/code> is used to remove the callback function, assuring that SetValues<\/code> is not called when it is not needed.<\/p>\n
private void OnDestroy()\r\n{\r\n\tConfigManager.FetchCompleted -= SetValues;\r\n}<\/pre>\n
With all the code in place, save the script and return to the Unity editor to perform some finishing touches and run the project.<\/p>\n
Testing the App<\/h2>\n
The first thing to do is attach the GetConfig <\/em>script to the Cube <\/em>object. Select the object in the Hierarchy <\/em>window and then click and drag the script into the Inspector <\/em>window.<\/p>\n
\"AddingFigure 9: Adding the GetConfig <\/em>script component<\/strong><\/p>\n
Now drag the object’s Mesh Renderer <\/em>component into the Rend <\/em>field, thereby allowing the program to change the cube’s color.<\/p>\n
\"Setting<\/p>\n
Figure 10: Setting Rend <\/em>to be the object’s Mesh Renderer <\/em>component<\/strong><\/p>\n
Finally, expand the Canvas <\/em>object to find your two text objects. Drag them into the corresponding fields in the GetConfig <\/em>component. Before selecting the two text objects, you may need to lock the inspector by clicking the padlock icon at the top.<\/p>\n
\"SettingFigure 11: Setting the text fields<\/strong><\/p>\n
You’re all set! Run the program in the editor using the play button at the top and notice how the text and cube color changes to reflect what’s currently in Remote Config. If you’re having trouble seeing the changes, then here’s a few things you can try:<\/p>\n