App Monetization — Ads, In-App Purchases & Subscriptions Strategy Guide

class MainActivity : AppCompatActivity() {
    private lateinit var adView: AdView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        MobileAds.initialize(this) { }

        adView = AdView(this).apply {
            adUnitId = "ca-app-pub-3940256099942544/6300978111" // Test ID
            adSize = AdSize.BANNER
            layoutParams = FrameLayout.LayoutParams(
                FrameLayout.LayoutParams.MATCH_PARENT,
                FrameLayout.LayoutParams.WRAP_CONTENT
            ).apply { gravity = Gravity.BOTTOM }
        }

        val adContainer = findViewById<FrameLayout>(R.id.ad_container)
        adContainer.addView(adView)

        val adRequest = AdRequest.Builder().build()
        adView.loadAd(adRequest)
    }

    override fun onDestroy() {
        adView.destroy()
        super.onDestroy()
    }
}

import GoogleMobileAds

class InterstitialManager: NSObject, GADFullScreenContentDelegate {
    private var interstitial: GADInterstitialAd?

    func loadAd() {
        let request = GADRequest()
        GADInterstitialAd.load(
            withAdUnitID: "ca-app-pub-3940256099942544/4411468910",
            request: request
        ) { [weak self] ad, error in
            if let error = error {
                print("Failed to load interstitial: \(error)")
                return
            }
            self?.interstitial = ad
            self?.interstitial?.fullScreenContentDelegate = self
        }
    }

    func showAd(from viewController: UIViewController) {
        guard let interstitial = interstitial else {
            print("Ad not ready")
            return
        }
        interstitial.present(fromRootViewController: viewController)
    }

    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
        loadAd() // Preload the next ad
    }
}

class BillingManager(private val context: Context) : PurchasesUpdatedListener {
    private val billingClient = BillingClient.newBuilder(context)
        .setListener(this)
        .enablePendingPurchases()
        .build()

    fun startConnection() {
        billingClient.startConnection(object : BillingClientStateListener {
            override fun onBillingSetupFinished(result: BillingResult) {
                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
                    queryProducts()
                }
            }
            override fun onBillingServiceDisconnected() {
                // Retry connection
            }
        })
    }

    private fun queryProducts() {
        val params = QueryProductDetailsParams.newBuilder()
            .setProductList(
                listOf(
                    QueryProductDetailsParams.Product.newBuilder()
                        .setProductId("remove_ads")
                        .setProductType(ProductType.INAPP)
                        .build(),
                    QueryProductDetailsParams.Product.newBuilder()
                        .setProductId("premium_monthly")
                        .setProductType(ProductType.SUBS)
                        .build()
                )
            )
            .build()

        billingClient.queryProductDetailsAsync(params) { result, productList ->
            // Store product details for display
        }
    }

    fun launchPurchase(activity: Activity, product: QueryProductDetailsParams.Product) {
        val flowParams = BillingFlowParams.newBuilder()
            .setProductDetailsParamsList(
                listOf(
                    BillingFlowParams.ProductDetailsParams.newBuilder()
                        .setProductDetails(product)
                        .build()
                )
            )
            .build()
        billingClient.launchBillingFlow(activity, flowParams)
    }

    override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
        if (result.responseCode == BillingClient.BillingResponseCode.OK && purchases != null) {
            for (purchase in purchases) {
                handlePurchase(purchase)
            }
        }
    }

    private fun handlePurchase(purchase: Purchase) {
        if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
            // Acknowledge the purchase
            val acknowledgeParams = AcknowledgePurchaseParams.newBuilder()
                .setPurchaseToken(purchase.purchaseToken)
                .build()
            billingClient.acknowledgePurchase(acknowledgeParams) { /* done */ }

            // Unlock the feature
            when (purchase.products[0]) {
                "remove_ads" -> Preferences.setAdsRemoved(true)
                "premium_monthly" -> Preferences.setPremium(true)
            }
        }
    }
}

import StoreKit

@MainActor
class PurchaseManager: ObservableObject {
    @Published var products: [Product] = []
    @Published var purchasedProductIDs: Set<String> = []

    func loadProducts() async {
        do {
            let products = try await Product.products(for: [
                "com.dodatech.remove_ads",
                "com.dodatech.premium_monthly",
                "com.dodatech.premium_yearly",
            ])
            self.products = products.sorted(by: { $0.price < $1.price })
        } catch {
            print("Failed to load products: \(error)")
        }
    }

    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await transaction.finish()
            purchasedProductIDs.insert(product.id)
        case .userCancelled:
            break
        case .pending:
            break
        @unknown default:
            break
        }
    }

    func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified:
            throw StoreError.failedVerification
        case .verified(let safe):
            return safe
        }
    }
}

enum StoreError: Error {
    case failedVerification
}

class RevenueCatManager {
    fun configure() {
        Purchases.configure(PurchaseConfiguration.Builder(context)
            .apiKey("your_revenuecat_api_key")
            .build()
        )
    }

    fun checkSubscriptionStatus() {
        Purchases.sharedInstance.getCustomerInfo { customerInfo, error ->
            if (customerInfo?.entitlements?.get("pro")?.isActive == true) {
                // User has active Pro subscription
                unlockProFeatures()
            }
        }
    }

    fun purchasePackage(activity: Activity, package: Package) {
        Purchases.sharedInstance.purchasePackage(activity, package) { customerInfo, _, error ->
            if (customerInfo?.entitlements?.get("pro")?.isActive == true) {
                unlockProFeatures()
            }
        }
    }

    fun restorePurchases() {
        Purchases.sharedInstance.restorePurchases { customerInfo, error ->
            if (customerInfo?.entitlements?.get("pro")?.isActive == true) {
                unlockProFeatures()
            }
        }
    }

    private fun unlockProFeatures() {
        // Enable premium features, remove ads, etc.
    }
}