Compras In-App para iOS y Android

25 de enero de 2024 Por: Artiko

defoldiapcomprasiosandroidmonetización

Compras In-App para iOS y Android

Las compras in-app son una forma crucial de monetización en juegos móviles. Esta guía te enseñará a implementar un sistema completo de IAP para ambas plataformas.

Configuración Base de IAP

1. Extensión y Dependencias

game.project Setup

[project]
dependencies = https://github.com/defold/extension-iap/archive/main.zip

[android]
package = com.miestudio.mijuego
minimum_sdk_version = 21
target_sdk_version = 34

[ios]
bundle_identifier = com.miestudio.mijuego

Permisos Android (AndroidManifest.xml)

<uses-permission android:name="com.android.vending.BILLING" />
<uses-permission android:name="android.permission.INTERNET" />

<application>
    <!-- Google Play Billing -->
    <service
        android:name="com.android.billingclient.api.BillingService"
        android:enabled="true"
        android:exported="false">
        <intent-filter>
            <action android:name="com.android.vending.billing.InAppBillingService.BIND" />
        </intent-filter>
    </service>
</application>

2. IAP Manager Base

Sistema de Gestión de Compras

-- iap_manager.script
local M = {}

function init(self)
    self.initialized = false
    self.products = {}
    self.pending_purchases = {}
    self.purchase_history = {}

    -- Estados de IAP
    self.state = {
        connected = false,
        processing = false,
        last_error = nil
    }

    -- Configuración
    self.config = {
        auto_finish_transactions = true,
        validate_receipts = true,
        retry_failed_purchases = true,
        max_retries = 3
    }

    -- Callbacks
    self.purchase_callbacks = {}
    self.product_callbacks = {}

    print("IAP Manager initialized")
end

function M.initialize(self, product_list, callback)
    if self.initialized then
        if callback then callback(true) end
        return
    end

    -- Configurar callback de IAP
    iap.set_callback(function(self, message_id, message)
        M.handle_iap_callback(self, message_id, message)
    end)

    -- Obtener lista de productos
    iap.list(product_list, function(self, result)
        if result.response == iap.RESPONSE_RESULT_OK then
            self:process_product_list(result.products)
            self.initialized = true
            self.state.connected = true

            print("IAP system initialized successfully")
            if callback then callback(true) end
        else
            print("IAP initialization failed: " .. (result.error or "Unknown error"))
            self.state.last_error = result.error
            if callback then callback(false, result.error) end
        end
    end)
end

function M.process_product_list(self, products)
    for _, product in ipairs(products) do
        self.products[product.ident] = {
            id = product.ident,
            title = product.title,
            description = product.description,
            price = product.price,
            price_string = product.price_string,
            currency_code = product.currency_code,
            type = product.type or "inapp"
        }

        print(string.format("Product loaded: %s - %s (%s)",
              product.ident, product.title, product.price_string))
    end
end

function M.handle_iap_callback(self, message_id, message)
    if message_id == iap.MSG_PURCHASE then
        self:handle_purchase_message(message)
    elseif message_id == iap.MSG_RESTORE then
        self:handle_restore_message(message)
    end
end

function M.handle_purchase_message(self, message)
    local product_id = message.ident
    local callback = self.purchase_callbacks[product_id]

    if message.state == iap.TRANS_STATE_PURCHASING then
        print("Purchase started for: " .. product_id)
        self.state.processing = true

    elseif message.state == iap.TRANS_STATE_PURCHASED then
        print("Purchase completed for: " .. product_id)
        self:process_successful_purchase(message, callback)

    elseif message.state == iap.TRANS_STATE_FAILED then
        print("Purchase failed for: " .. product_id .. " - " .. (message.error or "Unknown"))
        self:process_failed_purchase(message, callback)

    elseif message.state == iap.TRANS_STATE_RESTORED then
        print("Purchase restored for: " .. product_id)
        self:process_restored_purchase(message)
    end
end

return M

Configuración de Productos

1. Product Configuration

Catálogo de Productos

-- product_catalog.lua
local M = {}

M.PRODUCT_TYPES = {
    CONSUMABLE = "consumable",       -- Monedas, power-ups
    NON_CONSUMABLE = "non_consumable", -- Contenido permanente
    SUBSCRIPTION = "subscription"     -- Suscripciones
}

M.PRODUCTS = {
    -- Monedas
    {
        id = "coins_100",
        type = M.PRODUCT_TYPES.CONSUMABLE,
        category = "currency",
        base_price = 0.99,
        reward = {type = "coins", amount = 100},
        bonus = 0,
        popular = false
    },
    {
        id = "coins_500",
        type = M.PRODUCT_TYPES.CONSUMABLE,
        category = "currency",
        base_price = 3.99,
        reward = {type = "coins", amount = 500},
        bonus = 50,  -- 10% bonus
        popular = true
    },
    {
        id = "coins_1000",
        type = M.PRODUCT_TYPES.CONSUMABLE,
        category = "currency",
        base_price = 6.99,
        reward = {type = "coins", amount = 1000},
        bonus = 200, -- 20% bonus
        popular = false
    },

    -- Power-ups
    {
        id = "power_up_bundle",
        type = M.PRODUCT_TYPES.CONSUMABLE,
        category = "power_ups",
        base_price = 1.99,
        reward = {
            type = "bundle",
            items = {
                {type = "power_up", id = "shield", amount = 3},
                {type = "power_up", id = "speed", amount = 3},
                {type = "power_up", id = "magnet", amount = 3}
            }
        },
        popular = false
    },

    -- Contenido permanente
    {
        id = "remove_ads",
        type = M.PRODUCT_TYPES.NON_CONSUMABLE,
        category = "premium",
        base_price = 2.99,
        reward = {type = "feature", id = "no_ads"},
        popular = true
    },
    {
        id = "unlock_all_levels",
        type = M.PRODUCT_TYPES.NON_CONSUMABLE,
        category = "content",
        base_price = 4.99,
        reward = {type = "feature", id = "all_levels"},
        popular = false
    },

    -- Suscripciones
    {
        id = "premium_monthly",
        type = M.PRODUCT_TYPES.SUBSCRIPTION,
        category = "subscription",
        base_price = 4.99,
        period = "monthly",
        reward = {
            type = "subscription_benefits",
            benefits = {
                "no_ads",
                "daily_coins_500",
                "exclusive_skins",
                "double_xp"
            }
        },
        trial_period = 7, -- días
        popular = true
    }
}

function M.get_product_by_id(product_id)
    for _, product in ipairs(M.PRODUCTS) do
        if product.id == product_id then
            return product
        end
    end
    return nil
end

function M.get_products_by_category(category)
    local filtered = {}
    for _, product in ipairs(M.PRODUCTS) do
        if product.category == category then
            table.insert(filtered, product)
        end
    end
    return filtered
end

function M.get_popular_products()
    local popular = {}
    for _, product in ipairs(M.PRODUCTS) do
        if product.popular then
            table.insert(popular, product)
        end
    end
    return popular
end

return M

2. Store UI Manager

Interfaz de Tienda

-- store_ui_manager.gui_script
local product_catalog = require "main.product_catalog"
local iap_manager = require "main.iap_manager"

function init(self)
    self.store_container = gui.get_node("store_container")
    self.product_template = gui.get_node("product_template")
    self.close_button = gui.get_node("close_button")
    self.restore_button = gui.get_node("restore_button")

    -- Ocultar template
    gui.set_enabled(self.product_template, false)

    -- Estado de la tienda
    self.products_ui = {}
    self.selected_product = nil
    self.processing_purchase = false

    -- Crear UI de productos
    self:create_products_ui()

    -- Verificar compras restauradas
    self:check_owned_products()
end

function create_products_ui(self)
    local categories = {"currency", "power_ups", "premium", "subscription"}
    local y_offset = 0

    for _, category in ipairs(categories) do
        local products = product_catalog.get_products_by_category(category)

        if #products > 0 then
            -- Crear header de categoría
            y_offset = y_offset - 60
            self:create_category_header(category, y_offset)

            -- Crear productos
            for _, product in ipairs(products) do
                y_offset = y_offset - 120
                self:create_product_ui(product, y_offset)
            end
        end
    end
end

function create_product_ui(self, product, y_position)
    local product_node = gui.clone(self.product_template)
    gui.set_enabled(product_node, true)
    gui.set_parent(product_node, self.store_container)
    gui.set_position(product_node, vmath.vector3(0, y_position, 0))

    -- Configurar elementos del producto
    local title_node = gui.get_node("product_title", product_node)
    local desc_node = gui.get_node("product_description", product_node)
    local price_node = gui.get_node("product_price", product_node)
    local buy_button = gui.get_node("buy_button", product_node)
    local popular_badge = gui.get_node("popular_badge", product_node)

    -- Configurar textos
    gui.set_text(title_node, product.title or product.id)
    gui.set_text(desc_node, self:get_product_description(product))

    -- Configurar precio
    local iap_product = iap_manager:get_product(product.id)
    if iap_product then
        gui.set_text(price_node, iap_product.price_string)
    else
        gui.set_text(price_node, "$" .. product.base_price)
    end

    -- Mostrar badge de popular
    gui.set_enabled(popular_badge, product.popular or false)

    -- Configurar botón
    local owned = self:is_product_owned(product.id)
    if owned and product.type == product_catalog.PRODUCT_TYPES.NON_CONSUMABLE then
        gui.set_text(buy_button, "OWNED")
        gui.set_enabled(buy_button, false)
    else
        gui.set_text(buy_button, "BUY")
    end

    self.products_ui[product.id] = {
        node = product_node,
        product = product,
        buy_button = buy_button,
        price_node = price_node
    }
end

function get_product_description(self, product)
    if product.reward.type == "coins" then
        local total = product.reward.amount + (product.bonus or 0)
        if product.bonus and product.bonus > 0 then
            return string.format("%d coins (+%d bonus!)", product.reward.amount, product.bonus)
        else
            return string.format("%d coins", total)
        end

    elseif product.reward.type == "bundle" then
        return "Power-up bundle with shields, speed boost and coin magnet"

    elseif product.reward.type == "feature" then
        if product.reward.id == "no_ads" then
            return "Remove all advertisements permanently"
        elseif product.reward.id == "all_levels" then
            return "Unlock all levels and content"
        end

    elseif product.reward.type == "subscription_benefits" then
        return "Premium benefits: No ads, daily coins, exclusive content"
    end

    return product.description or "Premium content"
end

function on_input(self, action_id, action)
    if action_id == hash("touch") and action.pressed then
        -- Botón cerrar
        if gui.pick_node(self.close_button, action.x, action.y) then
            msg.post("main:/ui", "close_store")
            return true

        -- Botón restaurar
        elseif gui.pick_node(self.restore_button, action.x, action.y) then
            self:restore_purchases()
            return true

        -- Botones de compra
        else
            for product_id, ui_data in pairs(self.products_ui) do
                if gui.pick_node(ui_data.buy_button, action.x, action.y) then
                    self:purchase_product(product_id)
                    return true
                end
            end
        end
    end

    return false
end

function purchase_product(self, product_id)
    if self.processing_purchase then
        print("Purchase already in progress")
        return
    end

    local product = product_catalog.get_product_by_id(product_id)
    if not product then
        print("Product not found: " .. product_id)
        return
    end

    print("Initiating purchase for: " .. product_id)
    self.processing_purchase = true
    self.selected_product = product

    -- Mostrar loading
    self:show_purchase_loading(true)

    -- Realizar compra
    iap_manager:purchase_product(product_id, function(success, error, receipt)
        self:handle_purchase_result(product_id, success, error, receipt)
    end)
end

function handle_purchase_result(self, product_id, success, error, receipt)
    self.processing_purchase = false
    self:show_purchase_loading(false)

    if success then
        print("Purchase successful: " .. product_id)
        self:show_purchase_success(product_id)
        self:grant_product_reward(product_id, receipt)
    else
        print("Purchase failed: " .. (error or "Unknown error"))
        self:show_purchase_error(error)
    end

    self.selected_product = nil
end

function grant_product_reward(self, product_id, receipt)
    local product = product_catalog.get_product_by_id(product_id)
    if not product then return end

    local reward = product.reward

    if reward.type == "coins" then
        local total_coins = reward.amount + (product.bonus or 0)
        msg.post("main:/game_state", "add_coins", {amount = total_coins})

    elseif reward.type == "bundle" then
        for _, item in ipairs(reward.items) do
            msg.post("main:/game_state", "add_item", item)
        end

    elseif reward.type == "feature" then
        msg.post("main:/game_state", "unlock_feature", {feature = reward.id})

    elseif reward.type == "subscription_benefits" then
        msg.post("main:/game_state", "activate_subscription", {
            type = "premium",
            benefits = reward.benefits
        })
    end

    -- Registrar compra
    self:record_purchase(product_id, receipt)
end

return M

Validación de Recibos

1. Receipt Validation

Sistema de Validación

-- receipt_validator.lua
local M = {}

function init(self)
    self.validation_endpoint = sys.get_config("iap.validation_url", "")
    self.app_secret = sys.get_config("iap.app_secret", "")
    self.pending_validations = {}
end

function M.validate_receipt(self, receipt_data, product_id, callback)
    if not self.validation_endpoint or self.validation_endpoint == "" then
        print("No validation endpoint configured - skipping validation")
        if callback then callback(true, "validation_skipped") end
        return
    end

    local validation_id = self:generate_validation_id()
    self.pending_validations[validation_id] = {
        callback = callback,
        product_id = product_id,
        timestamp = socket.gettime()
    }

    -- Preparar datos para validación
    local platform = sys.get_sys_info().system_name
    local validation_data = {
        platform = platform == "iPhone OS" and "ios" or "android",
        receipt = receipt_data,
        product_id = product_id,
        app_secret = self.app_secret,
        validation_id = validation_id
    }

    -- Enviar al servidor
    self:send_validation_request(validation_data)
end

function send_validation_request(self, data)
    local headers = {
        ["Content-Type"] = "application/json",
        ["User-Agent"] = "DefoldGame/1.0"
    }

    local json_data = json.encode(data)

    http.request(self.validation_endpoint, "POST", function(self, id, response)
        self:handle_validation_response(data.validation_id, response)
    end, headers, json_data)
end

function handle_validation_response(self, validation_id, response)
    local validation = self.pending_validations[validation_id]
    if not validation then
        print("Validation response for unknown ID: " .. validation_id)
        return
    end

    local success = false
    local result = "validation_failed"

    if response.status == 200 then
        local ok, decoded = pcall(json.decode, response.response)
        if ok and decoded then
            success = decoded.valid == true
            result = decoded.result or "validation_completed"

            if success then
                print("Receipt validation successful for: " .. validation.product_id)
            else
                print("Receipt validation failed: " .. (decoded.error or "Invalid receipt"))
            end
        else
            print("Invalid JSON response from validation server")
        end
    else
        print("Validation server error: " .. response.status)
        result = "server_error"
    end

    -- Ejecutar callback
    if validation.callback then
        validation.callback(success, result)
    end

    self.pending_validations[validation_id] = nil
end

function generate_validation_id(self)
    return "val_" .. os.time() .. "_" .. math.random(10000, 99999)
end

-- Validación local para iOS (básica)
function M.validate_ios_receipt_local(receipt_data)
    -- Verificaciones básicas del formato
    if not receipt_data or receipt_data == "" then
        return false, "empty_receipt"
    end

    -- Verificar que es base64 válido
    local decoded = base64.decode(receipt_data)
    if not decoded then
        return false, "invalid_base64"
    end

    -- Verificaciones adicionales se harían en el servidor
    return true, "local_validation_passed"
end

-- Validación local para Android
function M.validate_android_receipt_local(receipt_data, signature)
    if not receipt_data or not signature then
        return false, "missing_data"
    end

    -- Verificar formato JSON
    local ok, decoded = pcall(json.decode, receipt_data)
    if not ok then
        return false, "invalid_json"
    end

    -- Verificaciones adicionales se harían en el servidor
    return true, "local_validation_passed"
end

return M

2. Server-Side Validation (Node.js Example)

Servidor de Validación

// validation_server.js
const express = require('express');
const https = require('https');
const {google} = require('googleapis');

const app = express();
app.use(express.json());

// Configuración
const APP_SECRET = process.env.APP_SECRET;
const GOOGLE_SERVICE_ACCOUNT = process.env.GOOGLE_SERVICE_ACCOUNT;

// Validación de recibos iOS
async function validateIOSReceipt(receiptData) {
    const postData = JSON.stringify({
        'receipt-data': receiptData,
        'password': APP_SECRET, // App-specific shared secret
        'exclude-old-transactions': true
    });

    // Primero intentar con producción
    let result = await makeIOSRequest('https://buy.itunes.apple.com/verifyReceipt', postData);

    // Si falla con código 21007, intentar con sandbox
    if (result.status === 21007) {
        result = await makeIOSRequest('https://sandbox.itunes.apple.com/verifyReceipt', postData);
    }

    return {
        valid: result.status === 0,
        result: result,
        environment: result.environment
    };
}

// Validación de recibos Android
async function validateAndroidReceipt(packageName, productId, purchaseToken) {
    try {
        const auth = new google.auth.GoogleAuth({
            keyFile: GOOGLE_SERVICE_ACCOUNT,
            scopes: ['https://www.googleapis.com/auth/androidpublisher']
        });

        const androidpublisher = google.androidpublisher({
            version: 'v3',
            auth: auth
        });

        const result = await androidpublisher.purchases.products.get({
            packageName: packageName,
            productId: productId,
            token: purchaseToken
        });

        return {
            valid: result.data.purchaseState === 0, // 0 = purchased
            result: result.data
        };
    } catch (error) {
        console.error('Android validation error:', error);
        return {
            valid: false,
            error: error.message
        };
    }
}

// Endpoint de validación
app.post('/validate', async (req, res) => {
    const {platform, receipt, product_id, app_secret, validation_id} = req.body;

    // Verificar app secret
    if (app_secret !== APP_SECRET) {
        return res.status(401).json({
            valid: false,
            error: 'Invalid app secret'
        });
    }

    try {
        let validation_result;

        if (platform === 'ios') {
            validation_result = await validateIOSReceipt(receipt);
        } else if (platform === 'android') {
            const {packageName, purchaseToken} = JSON.parse(receipt);
            validation_result = await validateAndroidReceipt(packageName, product_id, purchaseToken);
        } else {
            return res.status(400).json({
                valid: false,
                error: 'Unsupported platform'
            });
        }

        res.json({
            valid: validation_result.valid,
            result: validation_result.result,
            validation_id: validation_id
        });

    } catch (error) {
        console.error('Validation error:', error);
        res.status(500).json({
            valid: false,
            error: 'Validation failed'
        });
    }
});

function makeIOSRequest(url, postData) {
    return new Promise((resolve, reject) => {
        const options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(postData)
            }
        };

        const req = https.request(url, options, (res) => {
            let data = '';
            res.on('data', (chunk) => data += chunk);
            res.on('end', () => {
                try {
                    resolve(JSON.parse(data));
                } catch (error) {
                    reject(error);
                }
            });
        });

        req.on('error', reject);
        req.write(postData);
        req.end();
    });
}

app.listen(3000, () => {
    console.log('Validation server running on port 3000');
});

Purchase Analytics y Tracking

1. Purchase Analytics

Sistema de Analytics

-- purchase_analytics.lua
local M = {}

function init(self)
    self.purchase_events = {}
    self.revenue_tracking = {
        daily_revenue = 0,
        total_revenue = 0,
        purchases_count = 0,
        conversion_funnel = {
            store_visits = 0,
            product_views = 0,
            purchase_attempts = 0,
            successful_purchases = 0
        }
    }
end

function M.track_store_visit(self)
    self.revenue_tracking.conversion_funnel.store_visits =
        self.revenue_tracking.conversion_funnel.store_visits + 1

    self:send_analytics_event("store_visit", {
        timestamp = os.time(),
        session_id = self:get_session_id()
    })
end

function M.track_product_view(self, product_id)
    self.revenue_tracking.conversion_funnel.product_views =
        self.revenue_tracking.conversion_funnel.product_views + 1

    self:send_analytics_event("product_view", {
        product_id = product_id,
        timestamp = os.time()
    })
end

function M.track_purchase_attempt(self, product_id, price)
    self.revenue_tracking.conversion_funnel.purchase_attempts =
        self.revenue_tracking.conversion_funnel.purchase_attempts + 1

    self:send_analytics_event("purchase_attempt", {
        product_id = product_id,
        price = price,
        timestamp = os.time()
    })
end

function M.track_successful_purchase(self, product_id, price, currency, receipt)
    self.revenue_tracking.conversion_funnel.successful_purchases =
        self.revenue_tracking.conversion_funnel.successful_purchases + 1

    self.revenue_tracking.purchases_count = self.revenue_tracking.purchases_count + 1
    self.revenue_tracking.total_revenue = self.revenue_tracking.total_revenue + price
    self.revenue_tracking.daily_revenue = self.revenue_tracking.daily_revenue + price

    -- Enviar a múltiples plataformas de analytics
    self:send_purchase_events(product_id, price, currency, receipt)
end

function send_purchase_events(self, product_id, price, currency, receipt)
    -- Firebase Analytics
    self:send_analytics_event("purchase", {
        currency = currency,
        value = price,
        item_id = product_id,
        item_category = "iap"
    })

    -- Facebook Analytics
    msg.post("main:/facebook", "track_purchase", {
        amount = price,
        currency = currency,
        content_type = "product",
        content_id = product_id
    })

    -- AppsFlyer
    msg.post("main:/appsflyer", "track_purchase", {
        revenue = price,
        currency = currency,
        product_id = product_id,
        receipt_id = receipt
    })

    -- Adjust
    msg.post("main:/adjust", "track_revenue", {
        amount = price,
        currency = currency,
        product_id = product_id
    })
end

function M.get_conversion_rates(self)
    local funnel = self.revenue_tracking.conversion_funnel

    return {
        store_to_product = funnel.product_views / math.max(1, funnel.store_visits),
        product_to_attempt = funnel.purchase_attempts / math.max(1, funnel.product_views),
        attempt_to_purchase = funnel.successful_purchases / math.max(1, funnel.purchase_attempts),
        overall_conversion = funnel.successful_purchases / math.max(1, funnel.store_visits)
    }
end

function send_analytics_event(self, event_name, properties)
    -- Enviar a sistema de analytics principal
    msg.post("main:/analytics", "track_event", {
        event = event_name,
        properties = properties
    })
end

function get_session_id(self)
    return "session_" .. os.time()
end

return M

Subscription Management

1. Subscription Handler

Sistema de Suscripciones

-- subscription_manager.lua
local M = {}

function init(self)
    self.active_subscriptions = {}
    self.subscription_status = {}
    self.validation_interval = 24 * 60 * 60  -- Validar cada 24 horas
end

function M.handle_subscription_purchase(self, product_id, receipt_data)
    local subscription_data = {
        product_id = product_id,
        purchase_date = os.time(),
        receipt_data = receipt_data,
        status = "active",
        last_validated = os.time()
    }

    self.active_subscriptions[product_id] = subscription_data

    -- Activar beneficios
    self:activate_subscription_benefits(product_id)

    -- Programar validación periódica
    self:schedule_subscription_validation(product_id)

    print("Subscription activated: " .. product_id)
end

function activate_subscription_benefits(self, product_id)
    local product = product_catalog.get_product_by_id(product_id)
    if not product or not product.reward.benefits then return end

    for _, benefit in ipairs(product.reward.benefits) do
        if benefit == "no_ads" then
            msg.post("main:/game_state", "disable_ads")
        elseif benefit == "daily_coins_500" then
            msg.post("main:/game_state", "enable_daily_coins", {amount = 500})
        elseif benefit == "exclusive_skins" then
            msg.post("main:/game_state", "unlock_exclusive_content", {type = "skins"})
        elseif benefit == "double_xp" then
            msg.post("main:/game_state", "enable_xp_multiplier", {multiplier = 2.0})
        end
    end
end

function schedule_subscription_validation(self, product_id)
    timer.delay(self.validation_interval, true, function()
        self:validate_subscription_status(product_id)
    end)
end

function validate_subscription_status(self, product_id)
    local subscription = self.active_subscriptions[product_id]
    if not subscription then return end

    -- Validar con las tiendas
    local receipt_validator = require "main.receipt_validator"
    receipt_validator:validate_receipt(subscription.receipt_data, product_id,
        function(valid, result)
            if valid then
                subscription.last_validated = os.time()
                subscription.status = "active"
                print("Subscription validated: " .. product_id)
            else
                subscription.status = "expired"
                self:handle_subscription_expiry(product_id)
                print("Subscription expired: " .. product_id)
            end
        end)
end

function handle_subscription_expiry(self, product_id)
    -- Desactivar beneficios
    self:deactivate_subscription_benefits(product_id)

    -- Notificar al usuario
    msg.post("main:/ui", "show_subscription_expired", {product_id = product_id})

    -- Remover de activas
    self.active_subscriptions[product_id] = nil
end

function deactivate_subscription_benefits(self, product_id)
    local product = product_catalog.get_product_by_id(product_id)
    if not product or not product.reward.benefits then return end

    for _, benefit in ipairs(product.reward.benefits) do
        if benefit == "no_ads" then
            msg.post("main:/game_state", "enable_ads")
        elseif benefit == "daily_coins_500" then
            msg.post("main:/game_state", "disable_daily_coins")
        elseif benefit == "double_xp" then
            msg.post("main:/game_state", "disable_xp_multiplier")
        end
    end
end

function M.is_subscription_active(self, product_id)
    local subscription = self.active_subscriptions[product_id]
    return subscription and subscription.status == "active"
end

return M

Security y Anti-Fraud

1. Fraud Detection

Sistema Anti-Fraude

-- fraud_detector.lua
local M = {}

function init(self)
    self.fraud_signals = {}
    self.device_fingerprint = self:generate_device_fingerprint()
    self.purchase_patterns = {}
    self.risk_score = 0
end

function M.analyze_purchase_risk(self, product_id, price, user_data)
    local risk_factors = {}

    -- Factor 1: Velocidad de compras
    local purchase_velocity = self:calculate_purchase_velocity()
    if purchase_velocity > 5 then  -- Más de 5 compras en 1 hora
        table.insert(risk_factors, "high_velocity")
    end

    -- Factor 2: Patrón de precios
    local price_pattern = self:analyze_price_pattern(price)
    if price_pattern == "suspicious" then
        table.insert(risk_factors, "price_pattern")
    end

    -- Factor 3: Geolocalización (si está disponible)
    local geo_risk = self:check_geo_risk(user_data.country)
    if geo_risk then
        table.insert(risk_factors, "geo_risk")
    end

    -- Factor 4: Device fingerprint
    if self:is_device_suspicious() then
        table.insert(risk_factors, "device_risk")
    end

    -- Calcular score de riesgo
    local risk_score = #risk_factors * 0.25
    self.risk_score = math.min(1.0, risk_score)

    return {
        risk_score = self.risk_score,
        risk_factors = risk_factors,
        recommendation = self:get_risk_recommendation(self.risk_score)
    }
end

function calculate_purchase_velocity(self)
    local current_time = os.time()
    local recent_purchases = 0

    for _, purchase in ipairs(self.purchase_patterns) do
        if current_time - purchase.timestamp < 3600 then  -- Última hora
            recent_purchases = recent_purchases + 1
        end
    end

    return recent_purchases
end

function analyze_price_pattern(self, price)
    -- Detectar patrones sospechosos como:
    -- - Solo compras de productos de alto valor
    -- - Compras inmediatamente después de install
    -- - Compras repetidas del mismo producto

    local high_value_threshold = 10.0
    local recent_high_value = 0

    for _, purchase in ipairs(self.purchase_patterns) do
        if purchase.price >= high_value_threshold then
            recent_high_value = recent_high_value + 1
        end
    end

    if recent_high_value >= 3 and #self.purchase_patterns <= 5 then
        return "suspicious"
    end

    return "normal"
end

function check_geo_risk(self, country)
    -- Lista de países con alto riesgo de fraude
    local high_risk_countries = {
        "XX", "YY", "ZZ"  -- Códigos de país de ejemplo
    }

    for _, risk_country in ipairs(high_risk_countries) do
        if country == risk_country then
            return true
        end
    end

    return false
end

function is_device_suspicious(self)
    local sys_info = sys.get_sys_info()

    -- Verificar si es emulador
    if sys_info.device_model and string.find(sys_info.device_model, "Emulator") then
        return true
    end

    -- Verificar root/jailbreak (requiere extensión nativa)
    if sys_info.system_name == "Android" then
        -- Verificar indicadores de root
        local potential_root = sys_info.device_model == "sdk" or
                              sys_info.manufacturer == "Genymotion"
        if potential_root then
            return true
        end
    end

    return false
end

function get_risk_recommendation(self, risk_score)
    if risk_score < 0.3 then
        return "allow"
    elseif risk_score < 0.7 then
        return "review"
    else
        return "block"
    end
end

function generate_device_fingerprint(self)
    local sys_info = sys.get_sys_info()

    return {
        device_model = sys_info.device_model,
        manufacturer = sys_info.manufacturer,
        system_version = sys_info.system_version,
        language = sys_info.language,
        timezone = sys_info.timezone
    }
end

function M.record_purchase_attempt(self, product_id, price, result)
    table.insert(self.purchase_patterns, {
        product_id = product_id,
        price = price,
        result = result,
        timestamp = os.time()
    })

    -- Mantener solo los últimos 50 registros
    if #self.purchase_patterns > 50 then
        table.remove(self.purchase_patterns, 1)
    end
end

return M

Testing y Debug

1. IAP Debug Tools

Debug Console

-- iap_debug.gui_script
function init(self)
    self.debug_enabled = sys.get_config("project.debug", "0") == "1"

    if self.debug_enabled then
        self:create_debug_ui()
        self:setup_test_products()
    end
end

function create_debug_ui(self)
    -- Panel de debug
    self.debug_panel = gui.get_node("debug_panel")
    self.product_list = gui.get_node("product_list")
    self.test_buttons = {
        purchase = gui.get_node("test_purchase"),
        restore = gui.get_node("test_restore"),
        validate = gui.get_node("test_validate")
    }

    self:update_debug_display()
end

function setup_test_products(self)
    -- Productos de test para debug
    self.test_products = {
        "android.test.purchased",
        "android.test.canceled",
        "android.test.refunded",
        "android.test.item_unavailable"
    }
end

function on_input(self, action_id, action)
    if not self.debug_enabled or not action.pressed then
        return false
    end

    if action_id == hash("touch") then
        if gui.pick_node(self.test_buttons.purchase, action.x, action.y) then
            self:test_purchase()
            return true

        elseif gui.pick_node(self.test_buttons.restore, action.x, action.y) then
            self:test_restore()
            return true

        elseif gui.pick_node(self.test_buttons.validate, action.x, action.y) then
            self:test_validation()
            return true
        end
    end

    return false
end

function test_purchase(self)
    local test_product = self.test_products[1]  -- android.test.purchased
    print("Testing purchase: " .. test_product)

    local iap_manager = require "main.iap_manager"
    iap_manager:purchase_product(test_product, function(success, error, receipt)
        print("Test purchase result: " .. tostring(success))
        if error then
            print("Test purchase error: " .. error)
        end
    end)
end

function test_restore(self)
    print("Testing restore purchases")
    iap.restore()
end

function test_validation(self)
    print("Testing receipt validation")
    -- Simular validación con datos de test
    local receipt_validator = require "main.receipt_validator"
    receipt_validator:validate_receipt("test_receipt_data", "test_product",
        function(success, result)
            print("Test validation result: " .. tostring(success))
            print("Test validation details: " .. (result or "none"))
        end)
end

return M

Mejores Prácticas

1. User Experience

Mostrar precios claramente en moneda local
Explicar el valor de cada compra
Confirmar compras antes de procesar
Manejar errores gracefully
Providir restore button visible

2. Security

Validar todos los recibos en servidor
Implementar detección de fraude
Nunca confiar en validación local únicamente
Usar HTTPS para todas las comunicaciones
Proteger secrets y API keys

3. Business

Ofrecer variety de precios
Implementar analytics detallados
A/B test diferentes precios
Monitorear conversion rates
Optimizar timing de ofertas

4. Technical

Manejar network errors
Implementar retry logic
Cache product information
Handle subscription renewals
Test en multiple devices

Esta implementación completa te proporciona un sistema robusto de IAP que maneja todos los aspectos críticos de las compras in-app para dispositivos móviles.