Campaigns usage examples

Interstitial campaign

Let's imagine the situation that you need to request a campaign at the moment when the user has completed a level. To do this, you request a company for some event.

public class ResultScreen : MonoBehaviour
{
    [SerializeField]
    private Button _continueButton;

    private void Start()
    {
        _continueButton.OnClickAsObservable()
            .TakeUntilDestroy(this)
            .Subscribe(_ => Continue());
    }

    private async void Continue()
    {
        _continueButton.interactable = false;
        // this line of code runs the async processing of the campaign 
        // "level_finished" is the application event that the campaign was configured for
        await MagifyService.Instance.RequestCampaignAsync("level_finished");
        _continueButton.interactable = true;

        // Load the next level
    }
}

Products handling

Then you can have a class like wallet, which stores all the resources that the user has. Then in it you can observe Magify to handle all the products:

public class WalletManager
{
    private readonly Dictionary<string, float> _items = new();

    public async UniTask Initialize()
    {
        var magify = await MagifyService.WaitForInitialized();
        magify.Obtainer.OnProductObtained
            .Subscribe(result =>
            {
                // For example 'Type' and 'Quantity' for 'result.Product.Payout' elements might be:
                // 'Coins' and '150'
                // 'Diamonds' and '1'
                foreach (var payout in result.Product.Payout)
                {
                    _items[payout.Type] += payout.Quantity;
                }
            });
    }
}

Additional actions

Often before showing Interstitial ads, we disable sounds and music so that they do not conflict with advertising. You can add this code in your project to do it:

MagifyService.Instance.Advertiser.OnBeforeShowInterstitialVideo
    .TakeUntilDestroy(this) // If it's in MonoBehaviour
    .Subscribe(() => 
    {
        // Disable audio before inter
    });
    
MagifyService.Instance.Advertiser.OnAfterShowInterstitialVideo
    .TakeUntilDestroy(this) // If it's in MonoBehaviour
    .Subscribe(() => 
    {
        // Enable audio after inter
    });

Rewarded video campaign

Let's imagine a situation where you have a player who is having trouble playing the game and needs a hint. Then you can offer him to watch an advertisement for a reward in exchange for a hint. For this purpose you can implement the code as here.

public class GameScreen : MonoBehaviour
{
    [SerializeField]
    private Button _getHintButton;

    [Inject]
    private WalletManager _wallet;

    private void Start()
    {
        _getHintButton.OnClickAsObservable()
            .TakeUntilDestroy(this)
            .Subscribe(_ => GetHint());
    }

    private async UniTaskVoid GetHint()
    {
        _getHintButton.interactable = false;
        // this line of code runs the async processing of the campaign
        // "hint_tapped" is the application event that the campaign was configured for
        await MagifyService.Instance.RequestCampaignAsync("hint_tapped");

        if (_wallet.TrySpend("hint"))
        {
            // use hint
        }
        _getHintButton.interactable = true;
    }
}

Products handling

Then you can have a class like wallet, which stores all the resources that the user has and allow to spend them. Then in it you can observe Magify to handle all the products:

public class WalletManager
{
    private readonly Dictionary<string, float> _items = new();

    public async UniTask Initialize()
    {
        var magify = await MagifyService.WaitForInitialized();
        magify.Obtainer.OnProductObtained
            .Subscribe(result =>
            {
                // For example 'Type' and 'Quantity' for 'result.Product.Payout' elements might be:
                // 'hint' and '1'
                foreach (var payout in result.Product.Payout)
                {
                    _items[payout.Type] += payout.Quantity;
                }
            });
    }

    public bool TrySpend(string resource)
    {
        if (_items.ContainsKey(resource) && _items[resource] >= 0)
        {
            _items[resource] -= 1;
            return true;
        }
        return false;
    }
}

Additional actions

Often before showing Rewarded ads, we disable sounds and music so that they do not conflict with advertising. You can add this code in your project to do it:

MagifyService.Instance.Advertiser.OnBeforeShowRewardVideo
    .TakeUntilDestroy(this) // If it's in MonoBehaviour
    .Subscribe(() => 
    {
        // Disable audio before rewarded ads
    });
    
MagifyService.Instance.Advertiser.OnAfterShowRewardVideo
    .TakeUntilDestroy(this) // If it's in MonoBehaviour
    .Subscribe(() => 
    {
        // Enable audio after rewarded ads
    });

In-app campaign

Let's imagine that you have a skin system in your game. You want the player to be able to buy some skins. Then you can create a campaign that will be a skin store. This campaign will contain skins that the player can buy as a product.

public class HomeScreen : MonoBehaviour
{
    [SerializeField]
    private Button _openSkinShopButton;

    private void Start()
    {
        _openSkinShopButton.OnClickAsObservable()
            .TakeUntilDestroy(this)
            .Subscribe(_ => OpenSkinShop());
    }

    private async UniTaskVoid OpenSkinShop()
    {
        _openSkinShopButton.interactable = false;
        // this line of code runs the async processing of the campaign
        // "skin_shop" is the application event that the campaign was configured for
        // dictionary contains parameters for this campaign
        await MagifyService.Instance.RequestCampaignAsync("skin_shop", new Dictionary<string, object>
        {
            { "opened_from", "home_screen" },
        });

        _openSkinShopButton.interactable = true;
    }
}

Custom skin-shop popup

For the following code to work, the campaign must be configured with a custom creative. And ScreenId should be set for example with this value: "SkinShopScreenPrefab". At the same time, if you use ResourcesPopupsProvider, then your Resources folder must have a prefab with the same name "SkinShopScreenPrefab", as well as the SkinShopScreen component:

public class SkinShopScreen : PopupBase<CreativePopup.Args>, IPopupWithProducts<CreativePopup.Args>
{
    [SerializeField]
    private Button _buySelectedSkinButton;
    private ProductDef _selectedSkin;

    public event Action<ProductDef> OnClicked;

    protected override void PrepareForShow(CreativePopup.Args arguments, CompositeDisposable disposables)
    {
        base.PrepareForShow(arguments, disposables);
        foreach (var product in arguments.Products)
        {
            // fill this skin shop with products (skins)
        }

        _buySelectedSkinButton.OnClickAsObservable()
            .Subscribe(_ => BuySelectedSkin().Forget())
            .AddTo(disposables);
    }

    public void UpdateProducts(IReadOnlyList<ProductDef> products)
    {
        foreach (var product in products)
        {
            // refill this skin shop with products (skins)
        }
    }

    private async UniTaskVoid BuySelectedSkin()
    {
        _buySelectedSkinButton.interactable = false;
        OnClicked?.Invoke(_selectedSkin); // it will make Magify SDK initiate purchasing of in-app product
        _buySelectedSkinButton.interactable = true;
    }
}

Skin purchasing handling

As a result if the purchase completed successfully, then you can get the skin and give the player access to it.

public class SkinsManager
{
    private readonly List<string> _unlockedSkins = new();

    public async UniTask Initialize()
    {
        var magify = await MagifyService.WaitForInitialized();
        magify.Obtainer.OnProductObtained
            .Subscribe(result =>
            {
                _unlockedSkins.Add(result.Product.Id);
            });
    }
}

Subscription campaign

Let's imagine the classic scenario that you have an offer to purchase a subscription on the main screen. Clicking on this offer will show the player a campaign to purchase a subscription. After successful completion of this campaign you can check the subscription status and inform the player about it.

public class HomeScreen : MonoBehaviour
{
    [SerializeField]
    private Button _buySubscription;

    private void Start()
    {
        _buySubscription.OnClickAsObservable()
            .TakeUntilDestroy(this)
            .Subscribe(_ => BuySubscription().Forget());
    }

    private async UniTaskVoid BuySubscription()
    {
        _buySubscription.interactable = false;
        // this line of code runs the async processing of the campaign
        // "premium_subscription" is the application event that the campaign was configured for
        var result = await MagifyService.Instance.RequestCampaignAsync("premium_subscription");

        if (result == CampaignResult.Applied)
        {
            switch (MagifyService.Instance.Prefs.SubscriptionStatus.Value)
            {
                case SubscriptionStatus.Trial:
                    // let the user know that they have a trial subscription
                    break;
                case SubscriptionStatus.Paid:
                    // let the user know that they have purchased a subscription
                    break;
            }
        }

        _buySubscription.interactable = true;
    }
}

Bonus campaign

Let's imagine that you want to give a user a bonus for simply opening the app. For this purpose, a campaign can be configured for ConsentGivenEvent or SessionStartedEvent (see here) and with limit only once a day. In this case you will achieve the effect that the campaign triggers on the opening of the application but it triggers only once per day and the player can get the bonus only once per day.

public class FirstScreen : MonoBehaviour
{
    private async void Start()
    {
        // it triggers `ConsentGivenEvent` or `SessionStartedEvent` event
        await MagifyService.Instance.RequestSessionStartAsync();
    }
}

Products handling

Then you can have a class like wallet, which stores all the resources that the user has. Then in it you can observe Magify to handle all the products:

public class WalletManager
{
    private readonly Dictionary<string, float> _items = new();

    public async UniTask Initialize()
    {
        var magify = await MagifyService.WaitForInitialized();
        magify.Obtainer.OnProductObtained
            .Subscribe(result =>
            {
                // For example 'Type' and 'Quantity' for 'result.Product.Payout' elements might be:
                // 'Coins' and '10'
                foreach (var payout in result.Product.Payout)
                {
                    _items[payout.Type] += payout.Quantity;
                }
            });
    }
}