ArmorGamesAPI.hx

package com.avaloid.net;

import haxe.Timer;
import openfl.display.Stage;
import openfl.display.Loader;
import openfl.events.IOErrorEvent;
import openfl.events.Event;
import openfl.net.URLRequest;
import openfl.system.Security;
import com.avaloid.net.Settings;
import com.avaloid.utils.DynamicUtil;


class ArmorGamesAPI
{
    private static inline var TAG:String = "armor";
    private static inline var API_DOMAIN:String = "agi.armorgames.com";
    private static inline var API_URL:String = "http://agi.armorgames.com/assets/agi/AGI2.swf";
    private static inline var API_KEY:String = "<API_KEY>";

    private static var _agi:Dynamic;
    private static var _onComplete:Void->Void;
    private static var _onError:Void->Void;
    private static var _stage:Stage;
    private static var _onBuySuccess:String->String->Void;
    private static var _onBuyFail:String->Void;


    public static function init(stage, onComplete:Void->Void, onError:Void->Void):Void
    {
        _stage = stage;
        _onComplete = onComplete;
        _onError = onError;

        Security.allowDomain(API_DOMAIN);

        var loader:Loader = new Loader();

        loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onApiLoaded);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onApiFailedToLoad);
        loader.load(new URLRequest(API_URL));
    }

    public static function initStore(onSuccess:String->String->Void, onFail:String->Void):Void
    {
        _onBuySuccess = onSuccess;
        _onBuyFail = onFail;
    }

    public static function isConnected():Bool
    {
        return _agi != null && _agi.isConnected();
    }

    public static function isGuest():Bool
    {
        var result:Bool = true;

        if (_agi != null && _agi.user != null)
        {
            result = _agi.user.isGuest();
        }

        return result;
    }

    public static function getUserId():String
    {
        var result:String = null;

        if (_agi != null && _agi.user != null)
        {
            result = _agi.user.getUID();
        }

        return result;
    }

    public static function getUserName():String
    {
        var result:String = null;

        if (_agi != null && _agi.user != null)
        {
            result = _agi.user.getUsername();
        }

        return result;
    }

    public static function submitScore(score:Int):Void
    {
        if (_agi != null && _agi.scoreboard != null)
        {
            _agi.scoreboard.submit({scoreboardName: "stage", score: score});
        }
    }

    public static function buy(productId:String):Void
    {
        if (_agi == null || _agi.content == null)
        {
            Debug.custom(TAG, "buy: Api access error!");
            return;
        }

        var productInfo:Dynamic = Settings.getProductInfo(productId);

        if (productInfo == null)
        {
            Debug.custom(TAG, "buy: Product not found " + productId);
            return;
        }

        var sku:String = productInfo.armor_id;

        _agi.content.showStore({
            sku: sku,
            callback: onBuy
        });
    }

    private static function onBuy(data:Dynamic):Void
    {
        Debug.custom(TAG, "onBuy: " + data);

        if (data.success)
        {
            if (data.response == _agi.content.RESPONSE_USER_CANCELLED)
            {
                Debug.custom(TAG, "onBuy: RESPONSE_USER_CANCELLED");
            }
            else if (data.response ==_agi.content.RESPONSE_PURCHASE_FAILED)
            {
                Debug.custom(TAG, "onBuy: RESPONSE_PURCHASE_FAILED");
            }
            else if (data.response ==_agi.content.RESPONSE_PURCHASE_SUCCESS)
            {
                Debug.custom(TAG, "onBuy: RESPONSE_PURCHASE_SUCCESS " + data.purchases);

                var purchases:Array<Dynamic> = data.purchases;

                handleArmorBuy(purchases);
            }
        }
        else
        {
            if (_onBuyFail != null)
            {
                _onBuyFail(null);
            }
        }
    }

    private static function prepareArmorProduct(item:Dynamic):Dynamic
    {
        var product:Dynamic;

        var sku:String = item.sku;

        if (item.quantity == 0) return null;

        var currentProductInfo = Settings.getProductInfo(sku);
        if (currentProductInfo == null)
        {
            Debug.custom(TAG, "onBuy: Product not found " + sku);

            product = {
                id: "custom_" + item.quantity,
                armor_id: sku,
                quantity: 1
            };
        }
        else
        {
            product = {
                id: currentProductInfo.id,
                armor_id: sku,
                quantity: 1
            };
        }

        return product;
    }

    private static function handleArmorBuy(items:Array<Dynamic>):Void
    {
        var products = [];
        var productsIds = [];

        for (item in items)
        {
            var product:Dynamic = prepareArmorProduct(item);
            if (product != null)
            {
                if (productsIds.indexOf(product.id) == -1)
                {
                    products.push(product);
                    productsIds.push(product.id);
                }
            }
        }

        Server.registerArmorPurchases(DynamicUtil.stringify(products), onBuyRegistered);
    }

    private static function onBuyRegistered(data:Dynamic):Void
    {
        Debug.custom(TAG, "onBuyRegistered: " + data);

        var purchases:Array<Dynamic> = data.purchases;

        for (purchase in purchases)
        {
            var sku:Array<String> = purchase.sku.split(":");

            _agi.content.consume({
                sku: sku[0],
                amount: Std.int(Std.parseFloat(sku[1])),
                callback: function(consumeData:Dynamic):Void
                {
                    Debug.custom(TAG, "onConsumeData: " + consumeData);
                    if (consumeData.success)
                    {
                        _onBuySuccess(purchase.id, purchase.orderId);
                    }
                }
            });
        }
    }

    private static function onApiLoaded(event:Event):Void
    {
        _agi = event.currentTarget.content;

        _agi.connect({
            stage: _stage,
            apiKey: API_KEY,
            callback: function (data:Dynamic):Void
            {
                if (data.success)
                {
                    _onComplete();

                    // после загрузки апи, ждем несколько секунд и запрашиваем незавершенные покупки
                    Timer.delay(
                        function():Void
                        {
                            _agi.content.retrievePurchases(
                            {
                                callback: function(data:Dynamic):Void
                                {
                                    Debug.custom(TAG, "retrievePurchases: " + data);

                                    if (data.success == true)
                                    {
                                        var purchases:Array<Dynamic> = data.purchases;

                                        handleArmorBuy(purchases, true);
                                    }
                                    else
                                    {
                                        Debug.custom(TAG, "retrievePurchases error: " + data.error);
                                    }
                                }
                            });

                    }, 5000);
                }
                else
                {
                    Debug.custom(TAG, "Armor Games API init error: " + data.error);
                    _onError();
                }
            }
        });
    }

    private static function onApiFailedToLoad(event:Event):Void
    {
        _onError();
    }
}