Mobile Monetization Pro V2: Ads, IAP(In App Purchase) & More - Android & iOS

About Mobile Monetization Pro V2: Ads, IAP(In App Purchase) & More - Android & iOS – Unity Editor Tool & Plugin

Mobile Monetization Pro V2: Ads, IAP(In App Purchase) & More - Android & iOS Unity Asset Overview

If you have shipped mobile titles on Android and iOS, you already know the painful reality: setting up ad mediation, handling Unity IAP initialization logic, managing Google UMP consent forms, and keeping UI shop logic decoupled from your game core can turn into a maintenance nightmare. Mobile Monetization Pro V2 tackles this exact architectural headache by wrapping Google AdMob, Unity Ads, and native In-App Purchases into a unified, event-driven framework.

In my experience, the biggest failure point in mobile monetization code is state management—handling async initialization delays, loss of network connectivity, or delayed purchase validation callbacks. This asset introduces a centralized MonetizationManager service wrapper that acts as a bridge between the underlying native plugins (like UnityEngine.Purchasing and Google Mobile Ads SDK) and your game script logic. Instead of chaining messy singleton calls throughout your scene triggers, the tool exposes clean UnityEvents and C# delegates for ad loading, displaying, product validation, and localized price formatting.

Core Technical Features & Highlights

Architecturally, V2 cleans up much of the legacy boilerplate found in earlier wrapper tools. It segregates logic into specialized sub-modules: AdService, IAPService, and PrivacyConsentManager. Here is a technical breakdown of what stands out under the hood:

• Unified Ad Provider Layer: Automatically handles waterfall logic and fallback switches between primary providers (such as Google AdMob) and secondary networks (like Unity Ads or AppLovin MAX).
• Automated GDPR & Privacy Compliance: Features built-in support for Google's User Messaging Platform (UMP) and Apple’s App Tracking Transparency (ATT) framework, showing consent dialogs automatically before initializing tracking adapters.
• Data-Driven Storefront System: Uses ScriptableObject catalogs (ProductCatalogSO) to map product identifiers across Google Play Console and Apple App Store Connect without hardcoding strings in C# scripts.
• Local Receipt Parsing & Obfuscation: Includes built-in receipt validation helpers to parse purchase payloads locally before dispatching internal currency grants.
• UI Toolkit & Canvas Assemblies: Ships with production-ready Prefabs utilizing standard Unity UI (uGUI), configured with dynamic layout groups and responsive safe-area anchors.

Ideal Use Cases & Game Genres

While any mobile game selling virtual goods can use this package, certain architecture patterns benefit dramatically from this specific setup:

Hyper-Casual & Arcade Games

Hyper-casual titles rely heavily on high-frequency rewarded video prompts and interstitial timers between gameplay resets. The built-in ad cooldown timer and ready-status polling scripts mean you can wire up "Watch to Revive" or "2x Coins" buttons directly in the inspector without writing custom timer coroutines.

Mid-Core Mobile RPGs & Gacha Titles

For games with complex store layouts containing dynamic bundles, limited-time offers, and real-money currency packs, the dynamic grid generator reads your ProductCatalogSO file and instantiates items with localized currency strings instantly upon IAP store initialization.

Mobile Racing & Simulation Games

Games that sell both single purchases (e.g., "Remove Ads" non-consumables) and renewable upgrades (e.g., fuel packs or vehicle unlocks) benefit from the framework's reliable restore-purchases flow required by Apple App Store review guidelines.

Quick-Start Unity Setup & Integration Guide

Integrating Mobile Monetization Pro V2 into your workflow requires minimal setup. Here is the step-by-step developer workflow to get up and running in Unity 2021 LTS or newer.

1. Initialization & Configuration

After importing the package dependencies (ensure Unity IAP and Google Mobile Ads packages are present in your Package Manager), navigate to Tools > Mobile Monetization Pro > Configuration Settings. Add your App IDs and store product identifiers inside the inspector window.

2. Implementation Example

Here is how to hook into the initialization sequence, show a rewarded ad, and process an IAP purchase cleanly within a custom controller script:

using UnityEngine;
using MobileMonetizationPro;

public class GameEconomyManager : MonoBehaviour
{
    [SerializeField] private string removeAdsProductID = "com.studio.game.remove_ads";
    [SerializeField] private string rewardedPlacementID = "rewarded_double_coins";

    private void Start()
    {
        // Listen to initialization complete events
        MonetizationManager.Instance.OnServicesInitialized += HandleServicesReady;
        MonetizationManager.Instance.Initialize();
    }

    private void HandleServicesReady(bool status)
    {
        if (status)
        {
            Debug.Log("Monetization services ready for ad serving and purchases.");
            MonetizationManager.Instance.Ads.OnRewardedAdCompleted += GrantReward;
        }
    }

    public void TriggerRemoveAdsPurchase()
    {
        // Initiate store purchase flow
        MonetizationManager.Instance.IAP.BuyProduct(removeAdsProductID, (success, payload) => 
        {
            if (success)
            {
                Debug.Log("Successfully purchased Remove Ads!");
                // Disable interstitial display logic across the game
                MonetizationManager.Instance.Ads.SetAdFreeAccount(true);
            }
        });
    }

    public void ShowRewardedAd()
    {
        if (MonetizationManager.Instance.Ads.IsRewardedAdReady())
        {
            MonetizationManager.Instance.Ads.ShowRewardedAd(rewardedPlacementID);
        }
    }

    private void GrantReward(string placementId)
    {
        if (placementId == rewardedPlacementID)
        {
            Debug.Log("Player successfully watched ad. Granting double coins!");
        }
    }

    private void OnDestroy()
    {
        if (MonetizationManager.HasInstance)
        {
            MonetizationManager.Instance.OnServicesInitialized -= HandleServicesReady;
            MonetizationManager.Instance.Ads.OnRewardedAdCompleted -= GrantReward;
        }
    }
}

Pros & Cons Assessment

Honestly, every monetization framework has trade-offs depending on how much low-level control your project demands. Here is my pragmatic assessment after running this tool through stress tests on both iOS TestFlight and Android Internal Testing builds.

• Pros:
  • Decoupled Event Model: Keeps monetization code detached from your core game mechanics via standard C# events.
  • GDPR / ATT Out of the Box: Reduces compliance headaches by wrapping privacy consent flows automatically prior to SDK initialization.
  • Clean Fallback System: If primary ad network fill rates drop, the system automatically falls back to secondary networks seamlessly.
  • Inspector Friendly: Non-programmers can set up UI store prefabs and hook up button calls using UnityEvents directly in the inspector.
• Cons:
  • Dependency Updates: Because this package wraps third-party native SDKs (Google Mobile Ads, Unity IAP), you must ensure underlying plugin versions match the package's expected dependencies.
  • Setup Overhead for Ultra-Simple Games: If your project only requires a single non-consumable IAP and no ads, the full manager hierarchy might feel slightly over-engineered.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets