App features

Preparation

Remember, you need to configure and initialize the Magify Service to work with app features.

App features are available only with advanced Magify SDK integration.

Overview

Often we want to customize the application state remotely, or for example, customize depending on ab-tests, or some user state. For this purpose, our SDK provides a convenient way to centrally manage application settings, parameters and behavior that can be changed dynamically via remote features.

Our SDK takes responsibility for:

• Downloading and Caching: Responsible for downloading features data from the server, saving it to local storage, and reusing it without the need for repeated requests;
• Reactivity: Provides the ability to track feature changes in real time, making it easy to synchronize data state between business logic and the user interface;
• Flexibility: Allows working with different data types (boolean, numeric, string, files);
• Relevance: We follow changes in a user's state that may affect which features we want to give to them.

Basic usage

Currently app features in our SDK can be conditionally divided into 2 types: value-features and stored app features. The main difference is that the list of value-features is loaded together with the values of features, while stored app features values are separate files and are loaded separately from the list of current features.

Usually you only need value-features, but when you want to pass some large amount of customization data, it is better to package it in a separate file and put it in stored app features.

Below are examples of how to use all types of features.

Value-features

The simplest use case might look like this:

public class WinScreen : PopupBase<PopupArgs>
{
    [SerializeField]
    private Button _getRewardButton;
    [SerializeField]
    private TextMeshProUGUI _rewardAmountText;
    [SerializeField]
    private TextMeshProUGUI _rewardKindText;
    [SerializeField]
    private GameObject _specialOfferIcon;

    // Simple embedded wrapper over 'MagifyManager.Features.TryGetString' with default value
    private readonly StringRemoteProperty _rewardKind = new("win_screen_reward_kind", defaultValue: "Coins");

    protected override void PrepareForShow(PopupArgs arguments, CompositeDisposable disposables)
    {
        // getting boolean feature by name
        var showSpecialOfferIcon = MagifyService.Instance.Features.GetBool("win_screen_is_special_offer");
        _specialOfferIcon.SetActive(showSpecialOfferIcon);

        // default value
        var rewardAmount = 5.0;
        // trying to get number feature by name
        if (MagifyService.Instance.Features.TryGetNumber("win_screen_reward_amount", out var amount))
            rewardAmount = amount;
        _rewardAmountText.text = rewardAmount.ToString(CultureInfo.InvariantCulture);

        // trying to get remote feature or use default value
        _rewardKindText.text = _rewardKind.Value;

        _getRewardButton.OnClickAsObservable()
            .Subscribe(_ => { /* do something */ })
            .AddTo(disposables);
    }
}

As you can see, using features is quite easy. You can also use reactive versions:

public class GameActivityOverlay : MonoBehaviour
{
    [SerializeField]
    private GameObject _hintBooster;

    private void Start()
    {
        MagifyService.Instance.Features.GetReactiveBool("is_hint_booster_available")
            .TakeUntilDestroy(this)
            .Subscribe(isAvailable => _hitBooster.SetActive(isAvailable));
    }
}

Stored app features

One of the uses might be features that are important to start the app when you want the player to start the game with the actual settings.

public class Bootstrapper : MonoBehaviour
{
    private async void Start()
    {
        // your code ...
        // magify initialization code ...

        const string key = "startup_critical_features";
        if (MagifyService.Instance.Features.StoredAppFeatures.TryGet(key, out var storedAppFeature))
        {
            var storedAppFeatureContentHandle = await MagifyService.Instance.Features
                .LoadStoredAppFeature(storedAppFeature, destroyCancellationToken, timeoutSeconds: 5);
            if (storedAppFeatureContentHandle.Code == StorageResultCode.Success)
            {
                var criticalFeature = await storedAppFeatureContentHandle.Value.LoadString()!;
                // load your game with these critical features values
            }
        }

        // your code ...
    }
}

You can also enable background loading (preloading) of stored app features by our SDK via MagifyServiceArgs:

public class Bootstrapper : MonoBehaviour
{
    [SerializeField]
    private MagifySettings _magifySettings;

    private async void Start()
    {
        // your code ...

        var magifyServiceArgs = new MagifyServiceArgs()
        {
            EnableStoredAppFeaturesPreloading = true,
        };
        MagifyService.Initialize(_magifySettings, args: magifyServiceArgs);

        // your code ...
    }
}

In this case stored app features will be loaded at the discretion of the SDK, the most common cases of preloading are:

• When cold-starting applications;
• When internet access becomes available (in terms of Unity network reachability);
• When starting a new session (in terms of our SDK);
• After the first remote config has been successfully loaded (in this application run).