hyapp-h5/game-bridge/voice-room-game-bridge.v1.js

(function () {
    var remoteBridgeVersion = '20260609.1';

    function safeCall(fn, args) {
        try {
            if (typeof fn === 'function') {
                return fn.apply(window, args || []);
            }
        } catch (error) {
            post('debugLog', {
                message: String((error && error.message) || error),
            });
        }
        return null;
    }

    function readObject(value) {
        return value && typeof value === 'object' && !Array.isArray(value)
            ? value
            : {};
    }

    function readString(value) {
        if (value === null || value === undefined) {
            return '';
        }
        return String(value).trim();
    }

    function readPositiveInteger(value) {
        if (typeof value === 'number' && isFinite(value)) {
            return value > 0 ? Math.floor(value) : 0;
        }
        var text = readString(value);
        if (!/^[0-9]+$/.test(text)) {
            return 0;
        }
        var parsed = Number(text);
        return isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
    }

    function normalizeAdapterConfig(config, adapter) {
        if (adapter !== 'vivagames_v1') {
            return config;
        }
        var appId = readPositiveInteger(config.app_id);
        if (appId <= 0) {
            appId = readPositiveInteger(config.appId);
        }
        if (appId > 0) {
            config.app_id = appId;
            config.appId = appId;
        }
        return config;
    }

    function post(action, body) {
        var message = JSON.stringify({ action: action, payload: body || {} });
        if (postToChannel('GameBridgeChannel', message)) {
            return;
        }
        if (postToChannel('BaishunBridgeChannel', message)) {
            return;
        }
        if (postToChannel('LeaderBridgeChannel', message)) {
            return;
        }
        postToChannel('NativeBridge', message);
    }

    function postToChannel(name, message) {
        if (window[name] && window[name].postMessage) {
            window[name].postMessage(message);
            return true;
        }
        if (
            window.webkit &&
            window.webkit.messageHandlers &&
            window.webkit.messageHandlers[name] &&
            window.webkit.messageHandlers[name].postMessage
        ) {
            window.webkit.messageHandlers[name].postMessage(message);
            return true;
        }
        return false;
    }

    function launchPayload() {
        return readObject(window.hyappGameLaunchPayload);
    }

    function launchConfig() {
        var payload = launchPayload();
        return readObject(window.hyappGameLaunchConfig || payload.launchConfig);
    }

    function launchEntry() {
        var payload = launchPayload();
        return readObject(window.hyappGameEntry || payload.entry);
    }

    function detectAdapter(config, payload) {
        var values = [
            config.adapterType,
            config.adapter_type,
            config.platformCode,
            config.platform_code,
            config.vendorType,
            config.vendor_type,
            payload.vendorType,
            payload.vendor_type,
            payload.platformCode,
            payload.platform_code,
            payload.gameId,
            payload.game_id,
        ]
            .map(readString)
            .join('|')
            .toLowerCase();
        if (values.indexOf('vivagames') >= 0) {
            return 'vivagames_v1';
        }
        if (values.indexOf('baishun') >= 0) {
            return 'baishun_v1';
        }
        if (values.indexOf('leadercc') >= 0) {
            return 'leadercc_v1';
        }
        if (values.indexOf('zeeone') >= 0) {
            return 'zeeone_v1';
        }
        return 'generic';
    }

    function stringifyParams(body) {
        try {
            return JSON.stringify(body || {});
        } catch (_) {
            return '{}';
        }
    }

    function notifyVivaGames(method, body) {
        var params = body || {};
        safeCall(window.OnCallGame, [method, params]);
        try {
            window.postMessage(
                { method: method, params: stringifyParams(params) },
                '*'
            );
        } catch (_) {}
        try {
            if (
                window.parent &&
                window.parent !== window &&
                window.parent.postMessage
            ) {
                window.parent.postMessage(
                    { method: method, params: stringifyParams(params) },
                    '*'
                );
            }
        } catch (_) {}
    }

    function installAlias(name, action) {
        var fn = function (body) {
            return callNativeBridge(action || name, body);
        };
        fn.postMessage = function (body) {
            callNativeBridge(action || name, body);
        };
        window[name] = fn;
        window.webkit = window.webkit || {};
        window.webkit.messageHandlers = window.webkit.messageHandlers || {};
        window.webkit.messageHandlers[name] = { postMessage: fn.postMessage };
    }

    function callNativeBridge(action, body) {
        var config = launchConfig();
        var payload = launchPayload();
        var adapter = detectAdapter(config, payload);
        config = normalizeAdapterConfig(config, adapter);
        var normalized = readString(action);
        if (normalized === 'getConfig') {
            post('getConfig', body || {});
            if (adapter === 'vivagames_v1') {
                notifyVivaGames('getConfig', config);
            }
            return config;
        }
        if (normalized === 'getLaunchPayload') {
            post('getLaunchPayload', body || {});
            return payload;
        }
        post(normalized || 'NativeBridge', body || {});
        if (adapter === 'vivagames_v1') {
            notifyVivaGames(normalized || 'NativeBridge', body || {});
        }
        return null;
    }

    function installNativeBridge() {
        var config = launchConfig();
        var payload = launchPayload();
        var entry = launchEntry();
        var adapter = detectAdapter(config, payload);
        config = normalizeAdapterConfig(config, adapter);
        var nativeBridge = window.NativeBridge || {};
        var oldPostMessage =
            typeof nativeBridge.postMessage === 'function'
                ? nativeBridge.postMessage.bind(nativeBridge)
                : null;

        window.__hyappRemoteGameBridge = {
            adapter: adapter,
            version: remoteBridgeVersion,
            installedAt: Date.now(),
        };
        window.hyappGameLaunchPayload = payload;
        window.hyappGameLaunchConfig = config;
        window.hyappGameEntry = entry;
        window.__baishunLastConfig = config;
        window.baishunBridgeConfig = config;
        window.leaderLaunchPayload = payload;
        window.leaderLaunchConfig = config;
        window.leaderLaunchEntry = entry;

        nativeBridge.config = config;
        nativeBridge.launchConfig = config;
        nativeBridge.entry = entry;
        nativeBridge.launchPayload = payload;
        nativeBridge.getConfigSync = function () {
            return launchConfig();
        };
        nativeBridge.getLaunchPayloadSync = function () {
            return launchPayload();
        };
        nativeBridge.postMessage = function (body) {
            if (oldPostMessage) {
                oldPostMessage(
                    typeof body === 'string' ? body : stringifyParams(body)
                );
                return;
            }
            callNativeBridge('NativeBridge', body);
        };
        nativeBridge.getConfig = function (bodyOrCallback) {
            var currentConfig = launchConfig();
            if (typeof bodyOrCallback === 'function') {
                safeCall(bodyOrCallback, [currentConfig, launchPayload()]);
            }
            callNativeBridge('getConfig', bodyOrCallback || {});
            return currentConfig;
        };
        nativeBridge.getLaunchPayload = function (bodyOrCallback) {
            var currentPayload = launchPayload();
            if (typeof bodyOrCallback === 'function') {
                safeCall(bodyOrCallback, [currentPayload]);
            }
            callNativeBridge('getLaunchPayload', bodyOrCallback || {});
            return currentPayload;
        };
        nativeBridge.destroy = function (body) {
            callNativeBridge('destroy', body || {});
        };
        nativeBridge.closeGame = function (body) {
            callNativeBridge('closeGame', body || {});
        };
        nativeBridge.gameStart = function (body) {
            callNativeBridge('gameStart', body || {});
        };
        nativeBridge.gameLoading = function (body) {
            callNativeBridge('gameLoading', body || {});
        };
        nativeBridge.gameLoaded = function (body) {
            callNativeBridge('gameLoaded', body || {});
        };
        nativeBridge.loadComplete = function (body) {
            callNativeBridge('loadComplete', body || {});
        };
        nativeBridge.gameRecharge = function (body) {
            callNativeBridge('gameRecharge', body || {});
        };
        nativeBridge.pay = function (body) {
            callNativeBridge('pay', body || {});
        };
        nativeBridge.copyText = function (body) {
            callNativeBridge('copyText', body || {});
        };
        nativeBridge.refreshBalance = function (body) {
            callNativeBridge('refreshBalance', body || {});
        };
        nativeBridge.refreshBlance = function (body) {
            callNativeBridge('refreshBalance', body || {});
        };
        nativeBridge.debugLog = function (body) {
            callNativeBridge('debugLog', body || {});
        };
        window.NativeBridge = nativeBridge;

        [
            ['getConfig', 'getConfig'],
            ['destroy', 'destroy'],
            ['closeGame', 'closeGame'],
            ['gameStart', 'gameStart'],
            ['gameLoading', 'gameLoading'],
            ['gameLoaded', 'gameLoaded'],
            ['loadComplete', 'loadComplete'],
            ['gameRecharge', 'gameRecharge'],
            ['pay', 'pay'],
            ['copyText', 'copyText'],
            ['refreshBalance', 'refreshBalance'],
            ['refreshBlance', 'refreshBalance'],
            ['debugLog', 'debugLog'],
        ].forEach(function (item) {
            installAlias(item[0], item[1]);
        });

        if (adapter === 'vivagames_v1') {
            safeCall(window.OnCallGame, ['getConfig', config]);
        }
        signalReady(config, payload);
    }

    function signalReady(config, payload) {
        [
            ['hyappGameBridgeReady', payload],
            ['hyappRemoteGameBridgeReady', window.__hyappRemoteGameBridge],
            ['baishunBridgeReady', config],
            ['leaderLaunchConfig', payload],
            ['launchConfig', config],
        ].forEach(function (item) {
            try {
                window.dispatchEvent(
                    new CustomEvent(item[0], { detail: item[1] })
                );
                if (document && document.dispatchEvent) {
                    document.dispatchEvent(
                        new CustomEvent(item[0], { detail: item[1] })
                    );
                }
            } catch (_) {}
        });
    }

    window.HYAppGameBridge = window.HYAppGameBridge || {};
    window.HYAppGameBridge.install = installNativeBridge;
    window.HYAppGameBridge.version = remoteBridgeVersion;
    installNativeBridge();
})();