902 lines
29 KiB
JavaScript
902 lines
29 KiB
JavaScript
(function () {
|
|
var remoteBridgeVersion = '20260629.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';
|
|
}
|
|
if (values.indexOf('reyou') >= 0 || values.indexOf('hotgame') >= 0) {
|
|
return 'reyou_v1';
|
|
}
|
|
if (values.indexOf('zgame') >= 0) {
|
|
return 'zgame_v1';
|
|
}
|
|
if (values.indexOf('yomi') >= 0) {
|
|
return 'yomi_v4';
|
|
}
|
|
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 parseBridgePayload(value) {
|
|
if (typeof value === 'string') {
|
|
var text = value.trim();
|
|
if (!text) {
|
|
return {};
|
|
}
|
|
try {
|
|
var decoded = JSON.parse(text);
|
|
return decoded && typeof decoded === 'object'
|
|
? decoded
|
|
: { value: decoded };
|
|
} catch (_) {
|
|
return { raw: text };
|
|
}
|
|
}
|
|
if (value && typeof value === 'object') {
|
|
return value;
|
|
}
|
|
if (value === null || value === undefined) {
|
|
return {};
|
|
}
|
|
return { value: value };
|
|
}
|
|
|
|
function actionFromPayload(payload, fallbackAction) {
|
|
return (
|
|
readString(
|
|
payload.type ||
|
|
payload.action ||
|
|
payload.method ||
|
|
payload.name ||
|
|
payload.cmd ||
|
|
payload.event
|
|
) || fallbackAction
|
|
);
|
|
}
|
|
|
|
function invokeNamedCallback(callbackName, payload) {
|
|
var text = readString(callbackName);
|
|
if (
|
|
!/^[A-Za-z_$][0-9A-Za-z_$]*(\.[A-Za-z_$][0-9A-Za-z_$]*)*$/.test(
|
|
text
|
|
)
|
|
) {
|
|
return false;
|
|
}
|
|
var parts = text.split('.');
|
|
var target = window;
|
|
for (var i = 0; i < parts.length; i += 1) {
|
|
target = target[parts[i]];
|
|
if (target === null || target === undefined) {
|
|
return false;
|
|
}
|
|
}
|
|
if (typeof target !== 'function') {
|
|
return false;
|
|
}
|
|
safeCall(target, [payload || {}]);
|
|
return true;
|
|
}
|
|
|
|
function invokeNamedCallbackText(callbackName, payload) {
|
|
var text = readString(callbackName);
|
|
if (
|
|
!/^[A-Za-z_$][0-9A-Za-z_$]*(\.[A-Za-z_$][0-9A-Za-z_$]*)*$/.test(
|
|
text
|
|
)
|
|
) {
|
|
return false;
|
|
}
|
|
var parts = text.split('.');
|
|
var target = window;
|
|
for (var i = 0; i < parts.length; i += 1) {
|
|
target = target[parts[i]];
|
|
if (target === null || target === undefined) {
|
|
return false;
|
|
}
|
|
}
|
|
if (typeof target !== 'function') {
|
|
return false;
|
|
}
|
|
safeCall(target, [stringifyParams(payload || {})]);
|
|
return true;
|
|
}
|
|
|
|
function firstNonEmpty() {
|
|
for (var i = 0; i < arguments.length; i += 1) {
|
|
var value = readString(arguments[i]);
|
|
if (value) {
|
|
return value;
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
function readNumber(value, fallback) {
|
|
if (typeof value === 'number' && isFinite(value)) {
|
|
return value;
|
|
}
|
|
var text = readString(value);
|
|
if (!text) {
|
|
return fallback || 0;
|
|
}
|
|
var parsed = Number(text);
|
|
return isFinite(parsed) ? parsed : fallback || 0;
|
|
}
|
|
|
|
function zgameLaunchInfo() {
|
|
var config = launchConfig();
|
|
var payload = launchPayload();
|
|
var entry = launchEntry();
|
|
var openId = firstNonEmpty(
|
|
config.openId,
|
|
config.open_id,
|
|
config.userId,
|
|
config.user_id,
|
|
config.uid,
|
|
payload.openId,
|
|
payload.open_id,
|
|
payload.userId,
|
|
payload.user_id,
|
|
payload.uid
|
|
);
|
|
var jsCode = firstNonEmpty(
|
|
config.js_code,
|
|
config.jsCode,
|
|
config.code,
|
|
config.session,
|
|
config.token,
|
|
payload.js_code,
|
|
payload.jsCode,
|
|
payload.code,
|
|
payload.session,
|
|
payload.token
|
|
);
|
|
var userName = firstNonEmpty(
|
|
config.userName,
|
|
config.user_name,
|
|
config.nickname,
|
|
config.nickName,
|
|
payload.userName,
|
|
payload.user_name,
|
|
payload.nickname,
|
|
payload.nickName
|
|
);
|
|
var avatar = firstNonEmpty(
|
|
config.avatar,
|
|
config.avatarUrl,
|
|
config.avatar_url,
|
|
payload.avatar,
|
|
payload.avatarUrl,
|
|
payload.avatar_url
|
|
);
|
|
return {
|
|
openId: openId,
|
|
jsCode: jsCode,
|
|
userName: userName,
|
|
avatar: avatar,
|
|
balance: readNumber(
|
|
firstNonEmpty(
|
|
config.balance,
|
|
config.coin,
|
|
config.cash,
|
|
payload.balance,
|
|
payload.coin,
|
|
payload.cash
|
|
),
|
|
0
|
|
),
|
|
gameId: firstNonEmpty(
|
|
config.gameId,
|
|
config.game_id,
|
|
payload.gameId,
|
|
payload.game_id
|
|
),
|
|
roomId: firstNonEmpty(
|
|
config.roomId,
|
|
config.room_id,
|
|
payload.roomId,
|
|
payload.room_id
|
|
),
|
|
callbackBase: firstNonEmpty(
|
|
config.callbackBase,
|
|
config.callback_base,
|
|
payload.callbackBase,
|
|
payload.callback_base
|
|
),
|
|
merchantPayload: firstNonEmpty(
|
|
config.merchantPayload,
|
|
config.merchant_payload,
|
|
payload.merchantPayload,
|
|
payload.merchant_payload
|
|
),
|
|
launchUrl: firstNonEmpty(
|
|
entry.entryUrl,
|
|
entry.entry_url,
|
|
payload.launchUrl,
|
|
payload.launch_url
|
|
),
|
|
};
|
|
}
|
|
|
|
function zgameBridgePayload(resp, code, message) {
|
|
return {
|
|
error: {
|
|
code: readString(code || '0') || '0',
|
|
message: readString(message || 'success') || 'success',
|
|
},
|
|
resp: resp || {},
|
|
};
|
|
}
|
|
|
|
function zgameBridgeError(code, message) {
|
|
return zgameBridgePayload(
|
|
null,
|
|
code || '500',
|
|
message || 'bridge error'
|
|
);
|
|
}
|
|
|
|
function invokeZGameBridge(api, paramsJson, callbackName) {
|
|
var apiName = readString(api);
|
|
var normalized = apiName.toLowerCase();
|
|
var params = parseBridgePayload(paramsJson);
|
|
var info = zgameLaunchInfo();
|
|
var response;
|
|
try {
|
|
if (normalized === 'getuserinfo' || normalized === 'get_user_info') {
|
|
response = zgameBridgePayload({
|
|
openId: info.openId,
|
|
userName: info.userName,
|
|
nickname: info.userName,
|
|
avatar: info.avatar,
|
|
balance: info.balance,
|
|
gameId: info.gameId,
|
|
roomId: info.roomId,
|
|
callbackBase: info.callbackBase,
|
|
merchantPayload: info.merchantPayload,
|
|
});
|
|
} else if (normalized === 'login') {
|
|
if (!info.openId || !info.jsCode) {
|
|
response = zgameBridgeError(
|
|
'403',
|
|
'missing openId or js_code'
|
|
);
|
|
} else {
|
|
response = zgameBridgePayload({
|
|
js_code: info.jsCode,
|
|
openId: info.openId,
|
|
});
|
|
}
|
|
} else if (
|
|
normalized === 'closewebview' ||
|
|
normalized === 'closeweb_view' ||
|
|
normalized === 'close' ||
|
|
normalized === 'destroy'
|
|
) {
|
|
callNativeBridge('closeGame', params || {});
|
|
response = zgameBridgePayload({});
|
|
} else if (normalized === 'recharge' || normalized === 'pay') {
|
|
callNativeBridge('gameRecharge', params || {});
|
|
response = zgameBridgePayload({});
|
|
} else {
|
|
callNativeBridge(apiName || 'NativeBridge', params || {});
|
|
response = zgameBridgePayload({});
|
|
}
|
|
} catch (error) {
|
|
response = zgameBridgeError(
|
|
'500',
|
|
String((error && error.message) || error)
|
|
);
|
|
}
|
|
invokeNamedCallbackText(callbackName, response);
|
|
return response;
|
|
}
|
|
|
|
function installZGameBridgeAliases(nativeBridge) {
|
|
var previousBridge = window.ThirdPlatformBridge || {};
|
|
var zgameBridge = {};
|
|
Object.keys(previousBridge).forEach(function (key) {
|
|
zgameBridge[key] = previousBridge[key];
|
|
});
|
|
zgameBridge.__hyappZGameBridge = true;
|
|
zgameBridge.invoke = function (api, paramsJson, callbackName) {
|
|
return invokeZGameBridge(api, paramsJson, callbackName);
|
|
};
|
|
zgameBridge.getLaunchInfo = function () {
|
|
return zgameLaunchInfo();
|
|
};
|
|
window.ThirdPlatformBridge = zgameBridge;
|
|
if (
|
|
!window.WebViewJavascriptBridge ||
|
|
typeof window.WebViewJavascriptBridge.invoke !== 'function'
|
|
) {
|
|
window.WebViewJavascriptBridge = zgameBridge;
|
|
}
|
|
nativeBridge.thirdPlatformInvoke = zgameBridge.invoke;
|
|
}
|
|
|
|
function shouldInstallZGameBridge(adapter) {
|
|
if (adapter === 'zgame_v1') {
|
|
return true;
|
|
}
|
|
return (
|
|
zgameLaunchInfo().callbackBase.toLowerCase().indexOf('/zgame/') >=
|
|
0
|
|
);
|
|
}
|
|
|
|
function yomiActionResult(action, payload) {
|
|
var normalized = readString(action).toLowerCase();
|
|
if (normalized === 'insufficient') {
|
|
return {
|
|
action: 'insufficient',
|
|
result: 'success',
|
|
balance: payload && payload.balance,
|
|
};
|
|
}
|
|
if (normalized === 'hidesplash') {
|
|
return { action: 'hideSplash', result: 'success' };
|
|
}
|
|
if (normalized === 'closegame') {
|
|
return { action: 'closeGame', result: 'success' };
|
|
}
|
|
return { action: action, result: 'success' };
|
|
}
|
|
|
|
function postYomiAction(action, input) {
|
|
var payload = parseBridgePayload(input);
|
|
var normalized = actionFromPayload(payload, action);
|
|
if (!normalized) {
|
|
normalized = 'NativeBridge';
|
|
}
|
|
payload.type = payload.type || normalized;
|
|
payload.action = payload.action || normalized;
|
|
post(normalized, payload);
|
|
invokeNamedCallback(
|
|
payload.callback || payload.callbackName || payload.cb,
|
|
yomiActionResult(normalized, payload)
|
|
);
|
|
return yomiActionResult(normalized, payload);
|
|
}
|
|
|
|
function extractYomiBalance(payload) {
|
|
var body = parseBridgePayload(payload);
|
|
if (body.balance !== null && body.balance !== undefined) {
|
|
return body.balance;
|
|
}
|
|
if (body.amount !== null && body.amount !== undefined) {
|
|
return body.amount;
|
|
}
|
|
if (body.coin !== null && body.coin !== undefined) {
|
|
return body.coin;
|
|
}
|
|
if (body.balanceLabel !== null && body.balanceLabel !== undefined) {
|
|
return body.balanceLabel;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function notifyYomiGame(action, body) {
|
|
var normalized = readString(action);
|
|
if (normalized === 'onBalanceUpdate') {
|
|
var balance = extractYomiBalance(body);
|
|
if (balance === undefined) {
|
|
safeCall(window.onBalanceUpdate, []);
|
|
} else {
|
|
safeCall(window.onBalanceUpdate, [balance]);
|
|
}
|
|
}
|
|
if (normalized === 'setSound') {
|
|
var payload = parseBridgePayload(body);
|
|
var soundEnabled =
|
|
payload.bool !== undefined
|
|
? payload.bool
|
|
: payload.enabled !== undefined
|
|
? payload.enabled
|
|
: payload.value;
|
|
safeCall(window.setSound, [!!soundEnabled]);
|
|
}
|
|
if (normalized === 'passiveCloseGame') {
|
|
safeCall(window.passiveCloseGame, []);
|
|
}
|
|
try {
|
|
window.dispatchEvent(
|
|
new CustomEvent('yomiBridgeAction', {
|
|
detail: { action: normalized, payload: body || {} },
|
|
})
|
|
);
|
|
} catch (_) {}
|
|
}
|
|
|
|
function installYomiPostMessageListener() {
|
|
if (window.__hyappYomiPostMessageListenerInstalled) {
|
|
return;
|
|
}
|
|
window.__hyappYomiPostMessageListenerInstalled = true;
|
|
window.addEventListener('message', function (event) {
|
|
var data = parseBridgePayload(event && event.data);
|
|
if (readString(data.from).toLowerCase() !== 'yomi') {
|
|
return;
|
|
}
|
|
var action = actionFromPayload(data, '');
|
|
if (!action) {
|
|
return;
|
|
}
|
|
postYomiAction(action, data);
|
|
});
|
|
}
|
|
|
|
function installYomiBridgeAliases(nativeBridge) {
|
|
var previousYomi = window.yomi || {};
|
|
var yomiBridge = {};
|
|
var previousUpdateCoin =
|
|
typeof nativeBridge.updateCoin === 'function'
|
|
? nativeBridge.updateCoin.bind(nativeBridge)
|
|
: null;
|
|
|
|
yomiBridge.postMessage = function (message) {
|
|
var payload = parseBridgePayload(message);
|
|
return postYomiAction(
|
|
actionFromPayload(payload, 'NativeBridge'),
|
|
payload
|
|
);
|
|
};
|
|
yomiBridge.closeGame = function (body) {
|
|
return postYomiAction('closeGame', body || {});
|
|
};
|
|
yomiBridge.hideSplash = function (body) {
|
|
return postYomiAction('hideSplash', body || {});
|
|
};
|
|
yomiBridge.insufficient = function (body) {
|
|
return postYomiAction('insufficient', body || {});
|
|
};
|
|
yomiBridge.onBalanceUpdate = function (body) {
|
|
notifyYomiGame('onBalanceUpdate', body || {});
|
|
};
|
|
yomiBridge.setSound = function (body) {
|
|
notifyYomiGame('setSound', body || {});
|
|
};
|
|
yomiBridge.passiveCloseGame = function () {
|
|
notifyYomiGame('passiveCloseGame', {});
|
|
};
|
|
Object.keys(previousYomi).forEach(function (key) {
|
|
if (yomiBridge[key] === undefined) {
|
|
yomiBridge[key] = previousYomi[key];
|
|
}
|
|
});
|
|
window.yomi = yomiBridge;
|
|
window.webkit = window.webkit || {};
|
|
window.webkit.messageHandlers = window.webkit.messageHandlers || {};
|
|
window.webkit.messageHandlers.yomi = {
|
|
postMessage: yomiBridge.postMessage,
|
|
};
|
|
|
|
nativeBridge.insufficient = function (body) {
|
|
postYomiAction('insufficient', body || {});
|
|
};
|
|
nativeBridge.hideSplash = function (body) {
|
|
postYomiAction('hideSplash', body || {});
|
|
};
|
|
nativeBridge.onBalanceUpdate = function (body) {
|
|
notifyYomiGame('onBalanceUpdate', body || {});
|
|
};
|
|
nativeBridge.setSound = function (body) {
|
|
notifyYomiGame('setSound', body || {});
|
|
};
|
|
nativeBridge.passiveCloseGame = function () {
|
|
notifyYomiGame('passiveCloseGame', {});
|
|
};
|
|
nativeBridge.updateCoin = function (body) {
|
|
if (previousUpdateCoin) {
|
|
previousUpdateCoin(body || {});
|
|
}
|
|
notifyYomiGame('onBalanceUpdate', body || {});
|
|
};
|
|
|
|
installYomiPostMessageListener();
|
|
}
|
|
|
|
function notifyReyouRechargeSuccess(body) {
|
|
var payload = body || {};
|
|
var notified = false;
|
|
[window.rechargeSuccess, window.onRechargeSuccess].forEach(
|
|
function (fn) {
|
|
if (typeof fn === 'function') {
|
|
safeCall(fn, [payload]);
|
|
notified = true;
|
|
}
|
|
}
|
|
);
|
|
try {
|
|
window.dispatchEvent(
|
|
new CustomEvent('rechargeSuccess', { detail: payload })
|
|
);
|
|
} catch (_) {}
|
|
return notified;
|
|
}
|
|
|
|
function installReyouBridgeAliases(nativeBridge) {
|
|
var jsBridge = window.JsBridge || {};
|
|
jsBridge.recharge = function (body) {
|
|
return callNativeBridge('gameRecharge', body || {});
|
|
};
|
|
jsBridge.quit = function (body) {
|
|
return callNativeBridge('closeGame', body || {});
|
|
};
|
|
window.JsBridge = jsBridge;
|
|
|
|
installAlias('recharge', 'gameRecharge');
|
|
installAlias('quit', 'closeGame');
|
|
|
|
nativeBridge.recharge = function (body) {
|
|
callNativeBridge('gameRecharge', body || {});
|
|
};
|
|
nativeBridge.quit = function (body) {
|
|
callNativeBridge('closeGame', body || {});
|
|
};
|
|
nativeBridge.rechargeSuccess = function (body) {
|
|
notifyReyouRechargeSuccess(body || {});
|
|
};
|
|
nativeBridge.updateCoin = function (body) {
|
|
notifyReyouRechargeSuccess(body || {});
|
|
callNativeBridge('refreshBalance', body || {});
|
|
};
|
|
}
|
|
|
|
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 || {});
|
|
};
|
|
installReyouBridgeAliases(nativeBridge);
|
|
installYomiBridgeAliases(nativeBridge);
|
|
if (shouldInstallZGameBridge(adapter)) {
|
|
installZGameBridgeAliases(nativeBridge);
|
|
}
|
|
window.NativeBridge = nativeBridge;
|
|
|
|
[
|
|
['getConfig', 'getConfig'],
|
|
['destroy', 'destroy'],
|
|
['closeGame', 'closeGame'],
|
|
['hideSplash', 'hideSplash'],
|
|
['insufficient', 'insufficient'],
|
|
['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) {
|
|
var readyEvents = [
|
|
['hyappGameBridgeReady', payload],
|
|
['hyappRemoteGameBridgeReady', window.__hyappRemoteGameBridge],
|
|
['baishunBridgeReady', config],
|
|
['leaderLaunchConfig', payload],
|
|
['launchConfig', config],
|
|
];
|
|
if (
|
|
window.ThirdPlatformBridge &&
|
|
window.ThirdPlatformBridge.__hyappZGameBridge
|
|
) {
|
|
readyEvents.push(['zgameBridgeReady', window.ThirdPlatformBridge]);
|
|
}
|
|
readyEvents.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();
|
|
})();
|