FGL SDK User Guide

Unity (C#)

In Unity you first need to create some files to create the bridge between Unity + Javascript.

Step 1: Create the jslib file

Create a new file called FGLPlugin.jslib in your "Plugins" folder

Add the following code:

<code>
mergeInto(LibraryManager.library, {
    CallFGLInit: function (privateKeyPtr) {
        var privateKey = UTF8ToString(privateKeyPtr);        
        if (FGL && typeof FGL.init === "function") {
            FGL.init(privateKey);            
            SendMessage('FGLWebSDK', 'OnInitComplete');
        } else {
            console.error("FGL.init is not defined!");
        }
    },

    CallFGLRequest: function (adTypePtr) {
        var adType = UTF8ToString(adTypePtr);
        if (typeof FGL !== "undefined" && typeof FGL.Ads !== "undefined" && typeof FGL.Ads.request === "function") {
            FGL.Ads.request(adType)            
                .then(function (status) {                   
                    SendMessage('FGLWebSDK', 'AdComplete', status);
                })
                .catch(function (error) {
                    SendMessage('FGLWebSDK', 'AdError', error);                    
                });
        } else {
            console.error("FGL.Ads.request function not found!");
        }
    }
});

Step 2: Create the FGLWebSDK script

Create a folder in your project called "FGLWebSDK"

Create a new file called FGLWebSDK.cs in this new folder

Add the following code:

<code>
using System;
using System.Runtime.InteropServices;
using UnityEngine;

namespace FGL {


        public class FGLWebSDK : MonoBehaviour
        {
                private static FGLWebSDK _sdkSingleton;

                [DllImport("__Internal")]
                private static extern void CallFGLInit(string privateKey);

                [DllImport("__Internal")]
                private static extern void CallFGLRequest(string adType);

                public static void InitFGL(string privateKey)
                {
                        CheckSingleton();

                        Debug.Log("Calling InitFGL");
                        #if UNITY_WEBGL && !UNITY_EDITOR
                                CallFGLInit(privateKey);
                        #else
                                Debug.Log($"FGLWebSDK:: FGL Init called (non-WebGL environment) with privateKey: {privateKey}");
                        #endif
                }

                public static void RequestFGLAd(string adType,  Action<String> adError, Action<String> adFinished)
                {
                        CheckSingleton();

                        _sdkSingleton.errorCallback = adError;
                        _sdkSingleton.completeCallback = adFinished;

                        #if UNITY_WEBGL && !UNITY_EDITOR
                                CallFGLRequest(adType);
                                AudioListener.pause = true;
                        #else
                                Debug.Log($"FGLWebSDK:: FGL Request called (non-WebGL environment) with adType: {adType}");
                        #endif
                }
        
                
                
                private static void CheckSingleton()
                {
                        if (_sdkSingleton != null)
                        {
                                return;
                        }

                        var go = new GameObject();
                        _sdkSingleton = go.AddComponent<FGLWebSDK>();
                        
                        DontDestroyOnLoad(go);
                        go.name = "FGLWebSDK";
                }

                public Action<String> errorCallback;
                public Action<String> completeCallback;
                
                public void OnInitComplete() {
                        Debug.Log("FGLWebSDK:: OnInitComplete");
                }

                public void AdComplete(string status) {
                        Debug.Log("FGLWebSDK:: AdComplete - " + status);
                        AudioListener.pause = false;
                        if (completeCallback != null) {
                                completeCallback(status);
                        } 
                }

                public void AdError(string error) {
                        Debug.Log("FGLWebSDK:: AdError - " + error);
                        AudioListener.pause = false;
                        if (errorCallback != null) {
                                errorCallback(error);
                        } 
                }

                public void OnApplicationPause(bool pause)
                {
                            Debug.Log("FGLWebSDK:: OnApplicationPause - " + pause);
                        if (pause) {
                                AudioListener.pause = true;
                        } else {
                                AudioListener.pause = false;
                        }
                }
        }
}

How It Works

• JSLib: The jslib file acts as a bridge to javascript, it is also responsible for routing any responses back into Unity with the SendMessage call
• Initializing the SDK: In your initialization routine, call FGLWebSDK.InitFGL({your private key}) to initialize the SDK. This will also create the FGLWebSDK GameObject that will handle any callbacks

Godot (GDScript)

<code>
extends Node

var _sdk_initialized_callback
var _midgame_ad_result
var _rewarded_ad_result
var _sdk_initialized:bool = false
var _gd_midgame_callback:Callable
var _gd_rw_callback:Callable

# Godot GDScript Code
func initialize_sdk(private_key: String) -> void:
	# Check if the SDK is loaded		
	var is_sdk_loaded = JavaScriptBridge.eval("typeof FGL !== 'undefined'")
	var window = JavaScriptBridge.get_interface("window")

	if is_sdk_loaded:
		print("FGL SDK Detected.")
		_sdk_initialized_callback = JavaScriptBridge.create_callback(OnSDKInitialized)
		_midgame_ad_result = JavaScriptBridge.create_callback(OnMidgameAdResult)
		_rewarded_ad_result = JavaScriptBridge.create_callback(OnRewardedAdResult)
		window.OnSDKInitialized = _sdk_initialized_callback
		window.OnMidgameAdResult = _midgame_ad_result
		window.OnRewardedAdResult = _rewarded_ad_result
				 
		var init_code = """
			FGL.init('%s')
				.then(result => {
					if (result.success) {
						OnSDKInitialized('success');
					} else {
						OnSDKInitialized('failed');
					}
				})
				.catch(error => {
					OnSDKInitialized('error');
				});
	 """ % private_key
		JavaScriptBridge.eval(init_code)
		#setup ad requesting code
		var request_ad_js:String = """window.requestAd = async function(type) {
		try {
		let status = await FGL.Ads.request(type);
		let callback = (type.toLowerCase()==='midgame') ? window.OnMidgameAdResult : window.OnRewardedAdResult;
		console.log(`Ad load status: ${status}`);
		callback(status);
	} catch (e) {
		console.log("Error while loading ad: " + e);
		callback('failed');
	}
}"""
		JavaScriptBridge.eval(request_ad_js)
	else:
		print("FGL SDK is not loaded.")

func OnSDKInitialized(result:Array) -> void:
	if result[0] == "success":
		_sdk_initialized = true
		print("FGL SDK initialized successfully!")
	else:
		_sdk_initialized = false
		print("FGL SDK initialization failed: " + result[0])

LibGDX (Java)

<code>
// LibGDX Java Code
public void initializeSDK(String privateKey) {
    // Check if the SDK is loaded
    String checkSDKCode = "typeof FGL !== 'undefined'";
    boolean isSDKLoaded = (boolean) Gdx.app.getNet().evalJavaScript(checkSDKCode);

    if (isSDKLoaded) {
        // Initialize the SDK
        String initCode = String.format(
            "FGL.init('%s')" +
            ".then(result => {" +
                "if (result.success) {" +
                    "window.libgdxInstance.postMessage('OnSDKInitialized', 'success');" +
                "} else {" +
                    "window.libgdxInstance.postMessage('OnSDKInitialized', 'failed');" +
                "}" +
            "})" +
            ".catch(error => {" +
                "window.libgdxInstance.postMessage('OnSDKInitialized', 'error');" +
            "});",
            privateKey
        );
        Gdx.app.getNet().evalJavaScript(initCode);
    } else {
        Gdx.app.error("FGL SDK", "FGL SDK is not loaded.");
    }
}

// Callback method to handle initialization result
public void OnSDKInitialized(String result) {
    if (result.equals("success")) {
        Gdx.app.log("FGL SDK", "Initialized successfully!");
    } else {
        Gdx.app.error("FGL SDK", "Initialization failed: " + result);
    }
}

Unity (C#)

Change "rewards" to "midgame" to request a midgame ad instead.

<code>
// Unity C# Code
FGLWebSDK.RequestFGLAd("rewards", (error) =>         
{         
    Debug.Log("Rewarded Ad Error: " + error);
    
}, (status) =>
{            
    switch (status) {
        case "success":
            // Reward the player here
            Debug.Log("Ad was successfully shown. Reward the player.");
            GrantReward();
            break;
        case "failed":
            // Ad failed to load
            Debug.Log("Ad failed to load. Handle this gracefully.");
            RetryAdRequest();
            break;
        case "blocked":
            // Ad was blocked
            Debug.Log("Ad was blocked by the user's browser or ad-blocker.");
            ShowMessage("Ads are blocked. Please disable your ad-blocker to continue.");
            break;
    }
});

Godot (GDScript)

<code>
# rewardedCB should be a func that takes 1 parameter (String) which is the result (success,failure,blocked)
func requestRewardedAd(rewardedCB:Callable) -> bool:
    if not _sdk_initialized: return false
    _gd_rw_callback = rewardedCB
    JavaScriptBridge.eval("window.requestAd('rewards')")
    return true

# midCB should be a func that takes 1 parameter (String) which is the result (success,failure,blocked)
func requestMidgameAd(midCB:Callable) -> bool:
    if not _sdk_initialized: return false
    _gd_midgame_callback = midCB
    JavaScriptBridge.eval("window.requestAd('midgame')")
    return true
    
func OnMidgameAdResult(result:Array):
    if not _sdk_initialized: return
    if _gd_midgame_callback != null:
        _gd_midgame_callback.call(result[0])
        
func OnRewardedAdResult(result:Array):
    if not _sdk_initialized: return
    if _gd_rw_callback != null:
        _gd_rw_callback.call(result[0])

LibGDX (Java)

Coming Soon