Creating a package to config packages

Goal

I'm trying to create a config package for a scoped registry environment that can be used to add configuration values to other child packages that have a dependency on the config package. When the child package is included in a project it'd have modifiable fields in two locations:

1. In Builds, by a *.json file that gets dumped by the child package into the projects StreamingAssets folder.
2. In the Unity editor, by modifying a field in the inspector or an UnityEditor window.

Using ScriptableObjects

I have this working as a ScriptableObject in an embedded environment. Adding a new configurable value to a child package is done by inheriting a ScriptableObject based class from the config package and adding public fields to that class. This inheritance allows an *.asset file of the ScriptableObject in the child package to have the new fields in the UnityEditor without any additional work and is in a structure exportable to *.json. That *.asset file can be modified in projects that use the child package.

The *.json file is the source of truth. The ScriptableObject loads values in from the *.json file when the Unity editor starts. If values are modified in the ScriptableObject's inspector, they trigger OnValidate and overwrite the *.json file.

This method does now work when the package is in a scoped registry as that makes the package read only. This means the ScriptableObject in the child package can't be modified in the Unity Editor. Modifying the *.json file in builds still works fine.

Using Samples

Using the samples~ folder would lift the read-only issue. However, the package wouldn't be configurable if the sample isn't installed. Is there a way to force a sample of a package to be installed?

Using PlayerPrefs

I considered playerprefs, but didn't implement due to the work involved. I believe I'd have to replicate the way the inspector UI is generated for ScriptableObjects in a custom UnityEditor window. I'd also likely need a way for the config package to handle finding fields that were added by child packages. Despite the extra work, maybe player prefs is the only way?

Question

Maybe there are other ways I'm not thinking of. Is there a suggested way to store configuration values in a UPM package that can be modified in both the Unity editor and a build? Preferably in a way that the configuration logic can be a separate package that other package can have a dependency on.

 

I ended up using the package to generate a ScriptableObject into the project. This removes the ability to reference that ScriptableObject for any examples included in the package. Instead that ScriptableObject had to be duplicated for any examples. Otherwise this solution worked well.

I also investigated:

1. https://docs.unity3d.com/ScriptReference/PackageManager.Client.Embed.html turned out to do nothing in Unity 2019.3.12 when run from a scopedRegistry. At least it was different behavior than an error in the console when run from an embedded package.
2. Re-jigger Remote Config to be used for Local Config. This would have required too much re-jiggering. Got some feedback on the idea: https://forum.unity.com/threads/local-config.893419/
3. Saw that samples may be able to be force installed with https://docs.unity3d.com/ScriptReference/PackageManager.UI.Sample.Import.html

 

Thanks @maximeb_unity for the response!
Your suggestion is very close to what I ended up with. The config package provided an abstract class for a configurable package to extend and name its default ScriptableObject that would be generated. The only slight difference is I used SessionState strings to act as a singleton. The SessionState key was the ScriptableObject class name and the string value was set to the asset path after it searches for the type in the AssetDatabase on [InitializeOnLoadMethod]. Since, by default, rebuild is done often and searching the project for the ScriptableObject type seemed intensive, I also used SessionState to track if it's the first rebuild of the session. Only populating the "singleton" on the start of the session.

Addressable's is a great idea. I didn't think to look into that. I definitely will when/if I revisit this! Addressable could be a great way to force load in a part of the package this is editable.

Regarding `PackageManager.Client.Embed` I tried:

1. To embed a package that was already in my project. The entire package folder was copied/embedded into the Packages folder. The package was not referenced in manifest.json. When this setup ran `Client.Embed` it produced an error message correctly, as the package was already embedded.
2. Hooking manifest.json up to an internal Verdaccio npm registry. Then installing the package through the UPM UI. Running the `Client.Embed` code that was inside the package via a [UnityEditor.MenuItem("Edit/Remove UPM Readonly")]. This is the one that no longer returned an error (also correctly). However, it didn't seem to do anything else. The package was still read-only and didn't seem to be copied into the project.

I didn't try adding the package through `Client.Add` in script.